tree.h (tree_constructor): Remove IS_UNKNOWN_LOCATION.

2012-09-27  Dehao Chen  <dehao@google.com>

	* tree.h (tree_constructor): Remove IS_UNKNOWN_LOCATION.
	(extern void protected_set_expr_location): Likewise.
	(function_args_iter_next): Likewise.
	(inlined_function_outer_scope_p): Likewise.
	* input.h (IS_UNKNOWN_LOCATION): Likewise.
	* fold-const.c (expr_location_or): Likewise.
	* lto-cgraph.c (output_node_opt_summary): Likewise.
	* dwarf2out.c (add_src_coords_attributes): Likewise.
	* tree-eh.c (lower_try_finally_dup_block): Likewise.
	* profile.c (branch_prob):
	* cfgexpand.c (expand_gimple_cond): Likewise.
	(expand_gimple_basic_block): Likewise.
	(construct_exit_block): Likewise.
	(gimple_expand_cfg): Likewise.
	* cfgcleanup.c (try_forward_edges): Likewise.
	* tree-ssa-live.c (remove_unused_scope_block_p): Likewise.
	(dump_scope_block): Likewise.
	* ipa-prop.c (ipa_write_jump_function): Likewise.
	* rtl.h (extern void rtl_check_failed_flag): Likewise.
	* gimple.h (gimple_set_location): Likewise.
	(gimple_has_location): Likewise.
	* cfgrtl.c (unique_locus_on_edge_between_p): Likewise.
	(force_nonfallthru_and_redirect): Likewise.
	(fixup_reorder_chain): Likewise.
	(cfg_layout_merge_blocks): Likewise.

From-SVN: r191810

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 20217ba69b3787c46596223fa4d0675a051970a6..42deeba6caffd44324291290772670524947645c 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,31 @@
+2012-09-27  Dehao Chen  <dehao@google.com>
+
+       * tree.h (tree_constructor): Remove IS_UNKNOWN_LOCATION.
+       (extern void protected_set_expr_location): Likewise.
+       (function_args_iter_next): Likewise.
+       (inlined_function_outer_scope_p): Likewise.
+       * input.h (IS_UNKNOWN_LOCATION): Likewise.
+       * fold-const.c (expr_location_or): Likewise.
+       * lto-cgraph.c (output_node_opt_summary): Likewise.
+       * dwarf2out.c (add_src_coords_attributes): Likewise.
+       * tree-eh.c (lower_try_finally_dup_block): Likewise.
+       * profile.c (branch_prob):
+       * cfgexpand.c (expand_gimple_cond): Likewise.
+       (expand_gimple_basic_block): Likewise.
+       (construct_exit_block): Likewise.
+       (gimple_expand_cfg): Likewise.
+       * cfgcleanup.c (try_forward_edges): Likewise.
+       * tree-ssa-live.c (remove_unused_scope_block_p): Likewise.
+       (dump_scope_block): Likewise.
+       * ipa-prop.c (ipa_write_jump_function): Likewise.
+       * rtl.h (extern void rtl_check_failed_flag): Likewise.
+       * gimple.h (gimple_set_location): Likewise.
+       (gimple_has_location): Likewise.
+       * cfgrtl.c (unique_locus_on_edge_between_p): Likewise.
+       (force_nonfallthru_and_redirect): Likewise.
+       (fixup_reorder_chain): Likewise.
+       (cfg_layout_merge_blocks): Likewise.
+
 2012-09-27  Meador Inge  <meadori@codesourcery.com>
 
        * gcc-ar.c (main): Handle the returning of the sub-process error

diff --git a/gcc/cfgcleanup.c b/gcc/cfgcleanup.c
index cb53c96b545c51ce3eba1e1bda2e9b902fc86e2a..74ea30273897c03fca60ac06f3a8b83cf2c8c7b1 100644 (file)
--- a/gcc/cfgcleanup.c
+++ b/gcc/cfgcleanup.c
@@ -481,15 +481,15 @@ try_forward_edges (int mode, basic_block b)
                  int new_locus = single_succ_edge (target)->goto_locus;
                  int locus = goto_locus;
 
-                 if (!IS_UNKNOWN_LOCATION (new_locus)
-                     && !IS_UNKNOWN_LOCATION (locus)
+                 if (new_locus != UNKNOWN_LOCATION
+                     && locus != UNKNOWN_LOCATION
                      && new_locus != locus)
                    new_target = NULL;
                  else
                    {
                      rtx last;
 
-                     if (!IS_UNKNOWN_LOCATION (new_locus))
+                     if (new_locus != UNKNOWN_LOCATION)
                        locus = new_locus;
 
                      last = BB_END (target);
@@ -499,13 +499,13 @@ try_forward_edges (int mode, basic_block b)
                      new_locus = last && INSN_P (last)
                                  ? INSN_LOCATION (last) : 0;
 
-                     if (!IS_UNKNOWN_LOCATION (new_locus)
-                         && !IS_UNKNOWN_LOCATION (locus)
+                     if (new_locus != UNKNOWN_LOCATION
+                         && locus != UNKNOWN_LOCATION
                          && new_locus != locus)
                        new_target = NULL;
                      else
                        {
-                         if (!IS_UNKNOWN_LOCATION (new_locus))
+                         if (new_locus != UNKNOWN_LOCATION)
                            locus = new_locus;
 
                          goto_locus = locus;

diff --git a/gcc/cfgexpand.c b/gcc/cfgexpand.c
index 3f1638b7ff92044b81b2199bfc3a84d7c2a38024..299150e8ee23c6517c1596067c44cf464419b785 100644 (file)
--- a/gcc/cfgexpand.c
+++ b/gcc/cfgexpand.c
@@ -1838,7 +1838,7 @@ expand_gimple_cond (basic_block bb, gimple stmt)
       jumpif_1 (code, op0, op1, label_rtx_for_bb (true_edge->dest),
                true_edge->probability);
       maybe_dump_rtl_for_gimple_stmt (stmt, last);
-      if (!IS_UNKNOWN_LOCATION (true_edge->goto_locus))
+      if (true_edge->goto_locus != UNKNOWN_LOCATION)
        set_curr_insn_location (true_edge->goto_locus);
       false_edge->flags |= EDGE_FALLTHRU;
       maybe_cleanup_end_of_block (false_edge, last);
@@ -1849,7 +1849,7 @@ expand_gimple_cond (basic_block bb, gimple stmt)
       jumpifnot_1 (code, op0, op1, label_rtx_for_bb (false_edge->dest),
                   false_edge->probability);
       maybe_dump_rtl_for_gimple_stmt (stmt, last);
-      if (!IS_UNKNOWN_LOCATION (false_edge->goto_locus))
+      if (false_edge->goto_locus != UNKNOWN_LOCATION)
        set_curr_insn_location (false_edge->goto_locus);
       true_edge->flags |= EDGE_FALLTHRU;
       maybe_cleanup_end_of_block (true_edge, last);
@@ -1859,7 +1859,7 @@ expand_gimple_cond (basic_block bb, gimple stmt)
   jumpif_1 (code, op0, op1, label_rtx_for_bb (true_edge->dest),
            true_edge->probability);
   last = get_last_insn ();
-  if (!IS_UNKNOWN_LOCATION (false_edge->goto_locus))
+  if (false_edge->goto_locus != UNKNOWN_LOCATION)
     set_curr_insn_location (false_edge->goto_locus);
   emit_jump (label_rtx_for_bb (false_edge->dest));
 
@@ -1885,7 +1885,7 @@ expand_gimple_cond (basic_block bb, gimple stmt)
 
   maybe_dump_rtl_for_gimple_stmt (stmt, last2);
 
-  if (!IS_UNKNOWN_LOCATION (true_edge->goto_locus))
+  if (true_edge->goto_locus != UNKNOWN_LOCATION)
     {
       set_curr_insn_location (true_edge->goto_locus);
       true_edge->goto_locus = curr_insn_location ();
@@ -3973,7 +3973,7 @@ expand_gimple_basic_block (basic_block bb)
   /* Expand implicit goto and convert goto_locus.  */
   FOR_EACH_EDGE (e, ei, bb->succs)
     {
-      if (!IS_UNKNOWN_LOCATION (e->goto_locus))
+      if (e->goto_locus != UNKNOWN_LOCATION)
        set_curr_insn_location (e->goto_locus);
       if ((e->flags & EDGE_FALLTHRU) && e->dest != bb->next_bb)
        {
@@ -4094,7 +4094,7 @@ construct_exit_block (void)
 
   /* Make sure the locus is set to the end of the function, so that
      epilogue line numbers and warnings are set properly.  */
-  if (!IS_UNKNOWN_LOCATION (cfun->function_end_locus))
+  if (LOCATION_LOCUS (cfun->function_end_locus) != UNKNOWN_LOCATION)
     input_location = cfun->function_end_locus;
 
   /* Generate rtl for function exit.  */
@@ -4318,7 +4318,7 @@ gimple_expand_cfg (void)
   if (!DECL_IS_BUILTIN (current_function_decl))
     {
       /* Eventually, all FEs should explicitly set function_start_locus.  */
-      if (IS_UNKNOWN_LOCATION (cfun->function_start_locus))
+      if (LOCATION_LOCUS (cfun->function_start_locus) == UNKNOWN_LOCATION)
        set_curr_insn_location
          (DECL_SOURCE_LOCATION (current_function_decl));
       else

diff --git a/gcc/cfgrtl.c b/gcc/cfgrtl.c
index c04482ecca8a45920b420643ec3a930623172854..ad18400a064769097edcf847a47d3bbb7c9ce885 100644 (file)
--- a/gcc/cfgrtl.c
+++ b/gcc/cfgrtl.c
@@ -723,7 +723,7 @@ unique_locus_on_edge_between_p (basic_block a, basic_block b)
   const location_t goto_locus = EDGE_SUCC (a, 0)->goto_locus;
   rtx insn, end;
 
-  if (IS_UNKNOWN_LOCATION (goto_locus))
+  if (LOCATION_LOCUS (goto_locus) == UNKNOWN_LOCATION)
     return false;
 
   /* First scan block A backward.  */
@@ -1477,10 +1477,7 @@ force_nonfallthru_and_redirect (edge e, basic_block target, rtx jump_label)
   else
     jump_block = e->src;
 
-  if (!IS_UNKNOWN_LOCATION (e->goto_locus))
-    loc = e->goto_locus;
-  else
-    loc = 0;
+  loc = e->goto_locus;
   e->flags &= ~EDGE_FALLTHRU;
   if (target == EXIT_BLOCK_PTR)
     {
@@ -3335,7 +3332,7 @@ fixup_reorder_chain (void)
         edge_iterator ei;
 
         FOR_EACH_EDGE (e, ei, bb->succs)
-         if (!IS_UNKNOWN_LOCATION (e->goto_locus)
+         if (LOCATION_LOCUS (e->goto_locus) != UNKNOWN_LOCATION
              && !(e->flags & EDGE_ABNORMAL))
            {
              edge e2;
@@ -3385,7 +3382,7 @@ fixup_reorder_chain (void)
                 well, this can prevent other such blocks from being created
                 in subsequent iterations of the loop.  */
              for (ei2 = ei_start (dest->preds); (e2 = ei_safe_edge (ei2)); )
-               if (!IS_UNKNOWN_LOCATION (e2->goto_locus)
+               if (LOCATION_LOCUS (e2->goto_locus) != UNKNOWN_LOCATION
                    && !(e2->flags & (EDGE_ABNORMAL | EDGE_FALLTHRU))
                    && e->goto_locus == e2->goto_locus)
                  redirect_edge_and_branch (e2, nb);
@@ -4087,7 +4084,8 @@ cfg_layout_merge_blocks (basic_block a, basic_block b)
     }
 
   /* If B was a forwarder block, propagate the locus on the edge.  */
-  if (forwarder_p && IS_UNKNOWN_LOCATION (EDGE_SUCC (b, 0)->goto_locus))
+  if (forwarder_p
+      && LOCATION_LOCUS (EDGE_SUCC (b, 0)->goto_locus) != UNKNOWN_LOCATION)
     EDGE_SUCC (b, 0)->goto_locus = EDGE_SUCC (a, 0)->goto_locus;
 
   if (dump_file)

diff --git a/gcc/dwarf2out.c b/gcc/dwarf2out.c
index 8ee0f6a6327f517414eca234286d338b5546b974..c776f682b85224c275c63bbea84f1ec169c6ed2d 100644 (file)
--- a/gcc/dwarf2out.c
+++ b/gcc/dwarf2out.c
@@ -15552,7 +15552,7 @@ add_src_coords_attributes (dw_die_ref die, tree decl)
 {
   expanded_location s;
 
-  if (IS_UNKNOWN_LOCATION (DECL_SOURCE_LOCATION (decl)))
+  if (LOCATION_LOCUS (DECL_SOURCE_LOCATION (decl)) == UNKNOWN_LOCATION)
     return;
   s = expand_location (DECL_SOURCE_LOCATION (decl));
   add_AT_file (die, DW_AT_decl_file, lookup_filename (s.file));

diff --git a/gcc/fold-const.c b/gcc/fold-const.c
index 3197cef7703a5678c8c9f264e7c5893ea3ba6a09..ce522357ee29b0ae104e549cff45a5993f2b688d 100644 (file)
--- a/gcc/fold-const.c
+++ b/gcc/fold-const.c
@@ -145,7 +145,7 @@ static location_t
 expr_location_or (tree t, location_t loc)
 {
   location_t tloc = EXPR_LOCATION (t);
-  return IS_UNKNOWN_LOCATION (tloc) ? loc : tloc;
+  return tloc == UNKNOWN_LOCATION ? loc : tloc;
 }
 
 /* Similar to protected_set_expr_location, but never modify x in place,

diff --git a/gcc/gimple.h b/gcc/gimple.h
index 27887e8211f3bbcd4de09dfa0e7a5127fcd94c09..c4cdb1a309ae99ed5baed8fd435817e485ffb005 100644 (file)
--- a/gcc/gimple.h
+++ b/gcc/gimple.h
@@ -1240,7 +1240,7 @@ gimple_set_location (gimple g, location_t location)
 static inline bool
 gimple_has_location (const_gimple g)
 {
-  return !IS_UNKNOWN_LOCATION (gimple_location (g));
+  return LOCATION_LOCUS (gimple_location (g)) != UNKNOWN_LOCATION;
 }
 
 

diff --git a/gcc/input.h b/gcc/input.h
index 689e25be3f391eff47b087c6d7a1f1fd0f26bc69..412195a58b166574b978cad99133c3dc804fff93 100644 (file)
--- a/gcc/input.h
+++ b/gcc/input.h
@@ -56,9 +56,6 @@ extern location_t input_location;
 #define LOCATION_BLOCK(LOC) \
   ((tree) ((IS_ADHOC_LOC (LOC)) ? get_data_from_adhoc_loc (line_table, (LOC)) \
   : NULL))
-#define IS_UNKNOWN_LOCATION(LOC) \
-  ((IS_ADHOC_LOC (LOC)) ? get_location_from_adhoc_loc (line_table, LOC) == 0 \
-  : (LOC) == 0)
 
 #define input_line LOCATION_LINE (input_location)
 #define input_filename LOCATION_FILE (input_location)

diff --git a/gcc/ipa-prop.c b/gcc/ipa-prop.c
index 7e1354d1d511996c175f73206d95dfe4a48e9424..fb2346bdc45214fbcb90f9c04a40720ed9b2054f 100644 (file)
--- a/gcc/ipa-prop.c
+++ b/gcc/ipa-prop.c
@@ -3165,7 +3165,7 @@ ipa_write_jump_function (struct output_block *ob,
       break;
     case IPA_JF_CONST:
       gcc_assert (
-         IS_UNKNOWN_LOCATION (EXPR_LOCATION (jump_func->value.constant)));
+         EXPR_LOCATION (jump_func->value.constant) == UNKNOWN_LOCATION);
       stream_write_tree (ob, jump_func->value.constant, true);
       break;
     case IPA_JF_PASS_THROUGH:

diff --git a/gcc/lto-cgraph.c b/gcc/lto-cgraph.c
index a6ef6fc69df546ac5a300d11bb32d5a2d5f8c5be..f96ed3d36d3a56c01a95096d523ffa1d68706512 100644 (file)
--- a/gcc/lto-cgraph.c
+++ b/gcc/lto-cgraph.c
@@ -1412,7 +1412,7 @@ output_node_opt_summary (struct output_block *ob,
          mechanism to store function local declarations into summaries.  */
       gcc_assert (parm);
       streamer_write_uhwi (ob, parm_num);
-      gcc_assert (IS_UNKNOWN_LOCATION (EXPR_LOCATION (map->new_tree)));
+      gcc_assert (EXPR_LOCATION (map->new_tree) == UNKNOWN_LOCATION);
       stream_write_tree (ob, map->new_tree, true);
       bp = bitpack_create (ob->main_stream);
       bp_pack_value (&bp, map->replace_p, 1);

diff --git a/gcc/profile.c b/gcc/profile.c
index dd9c389fa1e4109c60d5475e77fe231f75c221d0..6d4a8d8beafdcb64204a1e32acdbee5ebc608fee 100644 (file)
--- a/gcc/profile.c
+++ b/gcc/profile.c
@@ -1123,7 +1123,7 @@ branch_prob (void)
             is not computed twice.  */
          if (last
              && gimple_has_location (last)
-             && !IS_UNKNOWN_LOCATION (e->goto_locus)
+             && LOCATION_LOCUS (e->goto_locus) != UNKNOWN_LOCATION
              && !single_succ_p (bb)
              && (LOCATION_FILE (e->goto_locus)
                  != LOCATION_FILE (gimple_location (last))
@@ -1344,7 +1344,8 @@ branch_prob (void)
 
          /* Notice GOTO expressions eliminated while constructing the CFG.  */
          if (single_succ_p (bb)
-             && !IS_UNKNOWN_LOCATION (single_succ_edge (bb)->goto_locus))
+             && LOCATION_LOCUS (single_succ_edge (bb)->goto_locus)
+                != UNKNOWN_LOCATION)
            {
              expanded_location curr_location
                = expand_location (single_succ_edge (bb)->goto_locus);

diff --git a/gcc/rtl.h b/gcc/rtl.h
index f0daf44ab83f5d048fd3ddb816b6ccb3cc50ddcc..cd5d4352b86e8ff159cad7bcd313683dc53cdfa0 100644 (file)
--- a/gcc/rtl.h
+++ b/gcc/rtl.h
@@ -829,7 +829,8 @@ extern void rtl_check_failed_flag (const char *, const_rtx, const char *,
 
 #define INSN_LOCATION(INSN) XUINT (INSN, 5)
 
-#define INSN_HAS_LOCATION(INSN) (!IS_UNKNOWN_LOCATION (INSN_LOCATION (INSN)))
+#define INSN_HAS_LOCATION(INSN) ((LOCATION_LOCUS (INSN_LOCATION (INSN)))\
+  != UNKNOWN_LOCATION)
 
 /* LOCATION of an RTX if relevant.  */
 #define RTL_LOCATION(X) (INSN_P (X) ? \

diff --git a/gcc/tree-eh.c b/gcc/tree-eh.c
index b0c006b07ae294fc3d6a2f0453f76b34d84bde79..94ed459f6f16f799a176863ab89bf6ec94c9ce83 100644 (file)
--- a/gcc/tree-eh.c
+++ b/gcc/tree-eh.c
@@ -885,7 +885,7 @@ lower_try_finally_dup_block (gimple_seq seq, struct leh_state *outer_state,
   for (gsi = gsi_start (new_seq); !gsi_end_p (gsi); gsi_next (&gsi))
     {
       gimple stmt = gsi_stmt (gsi);
-      if (IS_UNKNOWN_LOCATION (gimple_location (stmt)))
+      if (LOCATION_LOCUS (gimple_location (stmt)) == UNKNOWN_LOCATION)
        {
          tree block = gimple_block (stmt);
          gimple_set_location (stmt, loc);

diff --git a/gcc/tree-ssa-live.c b/gcc/tree-ssa-live.c
index e4505d6a69173fecf3c1197512b074e73fb7f0ed..7bf89d19fdb309e869b1105bb455a6789d41d993 100644 (file)
--- a/gcc/tree-ssa-live.c
+++ b/gcc/tree-ssa-live.c
@@ -597,7 +597,8 @@ remove_unused_scope_block_p (tree scope)
    else
    /* Verfify that only blocks with source location set
       are entry points to the inlined functions.  */
-     gcc_assert (IS_UNKNOWN_LOCATION (BLOCK_SOURCE_LOCATION (scope)));
+     gcc_assert (LOCATION_LOCUS (BLOCK_SOURCE_LOCATION (scope))
+                == UNKNOWN_LOCATION);
 
    TREE_USED (scope) = !unused;
    return unused;
@@ -671,7 +672,7 @@ dump_scope_block (FILE *file, int indent, tree scope, int flags)
   fprintf (file, "\n%*s{ Scope block #%i%s%s",indent, "" , BLOCK_NUMBER (scope),
           TREE_USED (scope) ? "" : " (unused)",
           BLOCK_ABSTRACT (scope) ? " (abstract)": "");
-  if (!IS_UNKNOWN_LOCATION (BLOCK_SOURCE_LOCATION (scope)))
+  if (LOCATION_LOCUS (BLOCK_SOURCE_LOCATION (scope)) != UNKNOWN_LOCATION)
     {
       expanded_location s = expand_location (BLOCK_SOURCE_LOCATION (scope));
       fprintf (file, " %s:%i", s.file, s.line);

diff --git a/gcc/tree.h b/gcc/tree.h
index 254eaef2a7175345bef3385829f12349a47de301..2050efd71e1df812e0dba37582d46af4f6d88b24 100644 (file)
--- a/gcc/tree.h
+++ b/gcc/tree.h
@@ -1612,7 +1612,8 @@ struct GTY(()) tree_constructor {
 #define EXPR_LOCATION(NODE) \
   (CAN_HAVE_LOCATION_P ((NODE)) ? (NODE)->exp.locus : UNKNOWN_LOCATION)
 #define SET_EXPR_LOCATION(NODE, LOCUS) EXPR_CHECK ((NODE))->exp.locus = (LOCUS)
-#define EXPR_HAS_LOCATION(NODE) (!IS_UNKNOWN_LOCATION (EXPR_LOCATION (NODE)))
+#define EXPR_HAS_LOCATION(NODE) (LOCATION_LOCUS (EXPR_LOCATION (NODE)) \
+  != UNKNOWN_LOCATION)
 /* The location to be used in a diagnostic about this expression.  Do not
    use this macro if the location will be assigned to other expressions.  */
 #define EXPR_LOC_OR_HERE(NODE) (EXPR_HAS_LOCATION (NODE) ? (NODE)->exp.locus : input_location)
@@ -1791,7 +1792,8 @@ extern void protected_set_expr_location (tree, location_t);
                                              OMP_CLAUSE_PRIVATE,       \
                                              OMP_CLAUSE_COPYPRIVATE), 0)
 #define OMP_CLAUSE_HAS_LOCATION(NODE) \
-  (!IS_UNKNOWN_LOCATION ((OMP_CLAUSE_CHECK (NODE))->omp_clause.locus))
+  (LOCATION_LOCUS ((OMP_CLAUSE_CHECK (NODE))->omp_clause.locus)                \
+  != UNKNOWN_LOCATION)
 #define OMP_CLAUSE_LOCATION(NODE)  (OMP_CLAUSE_CHECK (NODE))->omp_clause.locus
 
 /* True on an OMP_SECTION statement that was the last lexical member.
@@ -5535,7 +5537,7 @@ function_args_iter_next (function_args_iterator *i)
 static inline bool
 inlined_function_outer_scope_p (const_tree block)
 {
- return !IS_UNKNOWN_LOCATION (BLOCK_SOURCE_LOCATION (block));
+ return LOCATION_LOCUS (BLOCK_SOURCE_LOCATION (block)) != UNKNOWN_LOCATION;
 }
 
 /* Loop over all function arguments of FNTYPE.  In each iteration, PTR is set