From a71f0170085dfcd75bb03b38b0c1175e626541ff Mon Sep 17 00:00:00 2001
From: David Malcolm <dmalcolm@redhat.com>
Date: Wed, 11 Dec 2013 20:27:10 -0500
Subject: [PATCH 05/88] Introduce gimple_label and use it in a few places

gcc/
	* coretypes.h (gimple_label): New typedef.
	(const_gimple_label): New typedef.

	* gimple.h (struct gimple_statement_label): New subclass of
	gimple_statement_with_ops, adding the invariant that
	stmt->code == GIMPLE_LABEL.
	(is_a_helper <gimple_statement_label>::test): New.

	* gdbhooks.py (build_pretty_printer): Add gimple_label and its
	variants, reusing the gimple printer.

	* gimple-pretty-print.c (dump_gimple_label): Require a gimple_label
	rather than just a gimple.
	* tree-cfg.c (verify_gimple_label): Likewise.

	* gimple.c (gimple_build_label): Return a gimple_label rather than
	just a gimple.
	* gimple.h (gimple_build_label): Likewise.

	* gimplify.c (gimplify_case_label_expr): Update local to be a
	gimple_label.
	* tree-switch-conversion.c (gen_inbound_check): Likewise.

	* gimple-pretty-print.c (pp_gimple_stmt_1): Add checked cast to
	gimple_label in regions where a stmt is known to have code
	GIMPLE_LABEL.
	* tree-cfg.c (verify_gimple_stmt): Likewise.
---
 gcc/coretypes.h              |  4 ++++
 gcc/gdbhooks.py              |  2 ++
 gcc/gimple-pretty-print.c    |  4 ++--
 gcc/gimple.c                 |  5 +++--
 gcc/gimple.h                 | 24 +++++++++++++++++++++++-
 gcc/gimplify.c               |  6 +++---
 gcc/tree-cfg.c               |  4 ++--
 gcc/tree-switch-conversion.c |  2 +-
 8 files changed, 40 insertions(+), 11 deletions(-)

diff --git a/gcc/coretypes.h b/gcc/coretypes.h
index f8aeb94..24c6352 100644
--- a/gcc/coretypes.h
+++ b/gcc/coretypes.h
@@ -94,6 +94,10 @@ struct gimple_statement_cond;
 typedef struct gimple_statement_cond *gimple_cond;
 typedef const struct gimple_statement_cond *const_gimple_cond;
 
+struct gimple_statement_label;
+typedef struct gimple_statement_label *gimple_label;
+typedef const struct gimple_statement_label *const_gimple_label;
+
 struct gimple_statement_switch;
 typedef struct gimple_statement_switch *gimple_switch;
 typedef const struct gimple_statement_switch *const_gimple_switch;
diff --git a/gcc/gdbhooks.py b/gcc/gdbhooks.py
index d5162de..7514e45 100644
--- a/gcc/gdbhooks.py
+++ b/gcc/gdbhooks.py
@@ -460,6 +460,8 @@ def build_pretty_printer():
                               # Keep this in the same order as gimple.def:
                               'gimple_cond', 'const_gimple_cond',
                               'gimple_statement_cond *',
+                              'gimple_label', 'const_gimple_label',
+                              'gimple_statement_label *',
                               'gimple_switch', 'const_gimple_switch',
                               'gimple_statement_switch *',
                               'gimple_assign', 'const_gimple_assign',
diff --git a/gcc/gimple-pretty-print.c b/gcc/gimple-pretty-print.c
index 482fb1f..9766d57 100644
--- a/gcc/gimple-pretty-print.c
+++ b/gcc/gimple-pretty-print.c
@@ -863,7 +863,7 @@ dump_gimple_cond (pretty_printer *buffer, gimple_cond gs, int spc, int flags)
    TDF_* in dumpfils.h).  */
 
 static void
-dump_gimple_label (pretty_printer *buffer, gimple gs, int spc, int flags)
+dump_gimple_label (pretty_printer *buffer, gimple_label gs, int spc, int flags)
 {
   tree label = gimple_label_label (gs);
   if (flags & TDF_RAW)
@@ -2105,7 +2105,7 @@ pp_gimple_stmt_1 (pretty_printer *buffer, gimple gs, int spc, int flags)
       break;
 
     case GIMPLE_LABEL:
-      dump_gimple_label (buffer, gs, spc, flags);
+      dump_gimple_label (buffer, as_a <gimple_label> (gs), spc, flags);
       break;
 
     case GIMPLE_GOTO:
diff --git a/gcc/gimple.c b/gcc/gimple.c
index 5ffa357..7eff0b6 100644
--- a/gcc/gimple.c
+++ b/gcc/gimple.c
@@ -482,10 +482,11 @@ gimple_cond_set_condition_from_tree (gimple_cond stmt, tree cond)
 
 /* Build a GIMPLE_LABEL statement for LABEL.  */
 
-gimple
+gimple_label
 gimple_build_label (tree label)
 {
-  gimple p = gimple_build_with_ops (GIMPLE_LABEL, ERROR_MARK, 1);
+  gimple_label p =
+    as_a <gimple_label> (gimple_build_with_ops (GIMPLE_LABEL, ERROR_MARK, 1));
   gimple_label_set_label (p, label);
   return p;
 }
diff --git a/gcc/gimple.h b/gcc/gimple.h
index 285b1f2..0e34c67 100644
--- a/gcc/gimple.h
+++ b/gcc/gimple.h
@@ -780,6 +780,20 @@ struct GTY((tag("GSS_WITH_OPS")))
 };
 
 /* A statement with the invariant that
+      stmt->code == GIMPLE_LABEL
+   i.e. a label statement.
+
+   This type will normally be accessed via the gimple_label and
+   const_gimple_label typedefs (in coretypes.h), which are pointers to
+   this type.  */
+
+struct GTY((tag("GSS_WITH_OPS")))
+  gimple_statement_label : public gimple_statement_with_ops
+{
+  /* no additional fields; this uses the layout for GSS_WITH_OPS. */
+};
+
+/* A statement with the invariant that
       stmt->code == GIMPLE_SWITCH
    i.e. a switch statement.  */
 
@@ -850,6 +864,14 @@ is_a_helper <gimple_statement_cond *>::test (gimple gs)
 template <>
 template <>
 inline bool
+is_a_helper <gimple_statement_label *>::test (gimple gs)
+{
+  return gs->code == GIMPLE_LABEL;
+}
+
+template <>
+template <>
+inline bool
 is_a_helper <gimple_statement_resx *>::test (gimple gs)
 {
   return gs->code == GIMPLE_RESX;
@@ -1238,7 +1260,7 @@ gimple_assign gimple_build_assign_with_ops (enum tree_code, tree,
 gimple_cond gimple_build_cond (enum tree_code, tree, tree, tree, tree);
 gimple_cond gimple_build_cond_from_tree (tree, tree, tree);
 void gimple_cond_set_condition_from_tree (gimple_cond, tree);
-gimple gimple_build_label (tree label);
+gimple_label gimple_build_label (tree label);
 gimple gimple_build_goto (tree dest);
 gimple gimple_build_nop (void);
 gimple_bind gimple_build_bind (tree, gimple_seq, tree);
diff --git a/gcc/gimplify.c b/gcc/gimplify.c
index df4e085..f4cbe52 100644
--- a/gcc/gimplify.c
+++ b/gcc/gimplify.c
@@ -1531,7 +1531,7 @@ static enum gimplify_status
 gimplify_case_label_expr (tree *expr_p, gimple_seq *pre_p)
 {
   struct gimplify_ctx *ctxp;
-  gimple gimple_label;
+  gimple_label label_stmt;
 
   /* Invalid OpenMP programs can play Duff's Device type games with
      #pragma omp parallel.  At least in the C front end, we don't
@@ -1540,9 +1540,9 @@ gimplify_case_label_expr (tree *expr_p, gimple_seq *pre_p)
     if (ctxp->case_labels.exists ())
       break;
 
-  gimple_label = gimple_build_label (CASE_LABEL (*expr_p));
+  label_stmt = gimple_build_label (CASE_LABEL (*expr_p));
   ctxp->case_labels.safe_push (*expr_p);
-  gimplify_seq_add_stmt (pre_p, gimple_label);
+  gimplify_seq_add_stmt (pre_p, label_stmt);
 
   return GS_ALL_DONE;
 }
diff --git a/gcc/tree-cfg.c b/gcc/tree-cfg.c
index 6aef279..4652237 100644
--- a/gcc/tree-cfg.c
+++ b/gcc/tree-cfg.c
@@ -4429,7 +4429,7 @@ verify_gimple_debug (gimple stmt ATTRIBUTE_UNUSED)
    Returns true if anything is wrong.  */
 
 static bool
-verify_gimple_label (gimple stmt)
+verify_gimple_label (gimple_label stmt)
 {
   tree decl = gimple_label_label (stmt);
   int uid;
@@ -4479,7 +4479,7 @@ verify_gimple_stmt (gimple stmt)
       return verify_gimple_assign (as_a <gimple_assign> (stmt));
 
     case GIMPLE_LABEL:
-      return verify_gimple_label (stmt);
+      return verify_gimple_label (as_a <gimple_label> (stmt));
 
     case GIMPLE_CALL:
       return verify_gimple_call (stmt);
diff --git a/gcc/tree-switch-conversion.c b/gcc/tree-switch-conversion.c
index 084eb1b..7691aeb 100644
--- a/gcc/tree-switch-conversion.c
+++ b/gcc/tree-switch-conversion.c
@@ -1243,7 +1243,7 @@ gen_inbound_check (gimple_switch swtch, struct switch_conv_info *info)
   tree label_decl1 = create_artificial_label (UNKNOWN_LOCATION);
   tree label_decl2 = create_artificial_label (UNKNOWN_LOCATION);
   tree label_decl3 = create_artificial_label (UNKNOWN_LOCATION);
-  gimple label1, label2, label3;
+  gimple_label label1, label2, label3;
   tree utype, tidx;
   tree bound;
 
-- 
1.8.5.3

