* alias.c (nonlocal_mentioned_p):

	Rename CONST_CALL_P to CONST_OR_PURE_CALL_P
	* calls.c (emit_call_1): Likewise.
	* cse.c (cse_insn, invalidate_skipped_block): Likewise.
	* cselib.c (cselib_process_insn): Likewise.
	* df.c (df_insns_modify): Likewise.
	* flow.c (need_fake_edge_p): Likewise.
	(propagate_one_insn): Likewise.
	* haifa-sched.c (reemit_notes): Likewise.
	* integrate.c (copy_insn_list): Likewise.
	* jump.c (delete_prior_computation): Likewise.
	* local-alloc.c (validate_equiv_mem): Likewise.
	* loop.c (scan_loop): Likewise.
	* predict.c (estimate_probability): Likewise.
	* reload.c (reload): Likewise.
	* sched-deps (sched_analyze): Likewise.
	* rtl.h (CONST_CALL_P): rename to CONST_OR_PURE_CALL_P.
	* gcse.c (compute_hash_table): Likewise.
	(mark_call): Likewise.
	(store_killed_in_insn): Likewise.


git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@44688 138bc75d-0d04-0410-961f-82ee72b054a4

17 files changed, 50 insertions, 24 deletions

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 19e50caf64c..e3820fd8579 100644
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,26 @@
+Tue Aug  7 14:56:16 CEST 2001  Jan Hubicka  <jh@suse.cz>
+
+	* alias.c (nonlocal_mentioned_p):
+	Rename CONST_CALL_P to CONST_OR_PURE_CALL_P
+	* calls.c (emit_call_1): Likewise.
+	* cse.c (cse_insn, invalidate_skipped_block): Likewise.
+	* cselib.c (cselib_process_insn): Likewise.
+	* df.c (df_insns_modify): Likewise.
+	* flow.c (need_fake_edge_p): Likewise.
+	(propagate_one_insn): Likewise.
+	* haifa-sched.c (reemit_notes): Likewise.
+	* integrate.c (copy_insn_list): Likewise.
+	* jump.c (delete_prior_computation): Likewise.
+	* local-alloc.c (validate_equiv_mem): Likewise.
+	* loop.c (scan_loop): Likewise.
+	* predict.c (estimate_probability): Likewise.
+	* reload.c (reload): Likewise.
+	* sched-deps (sched_analyze): Likewise.
+	* rtl.h (CONST_CALL_P): rename to CONST_OR_PURE_CALL_P.
+	* gcse.c (compute_hash_table): Likewise.
+	(mark_call): Likewise.
+	(store_killed_in_insn): Likewise.
+
 2001-08-07  Jason Merrill  <jason_merrill@redhat.com>
 
 	* c-semantics.c (make_rtl_for_local_static): Use DECL_RTL_SET_P.
diff --git a/gcc/alias.c b/gcc/alias.c
index a529a01cfa6..e26e13c2c97 100644
--- a/gcc/alias.c
+++ b/gcc/alias.c
@@ -1941,7 +1941,7 @@ nonlocal_mentioned_p (x)
     {
       /* Constant functions can be constant if they don't use
          scratch memory used to mark function w/o side effects.  */
-      if (code == CALL_INSN && CONST_CALL_P (x))
+      if (code == CALL_INSN && CONST_OR_PURE_CALL_P (x))
         {
 	  x = CALL_INSN_FUNCTION_USAGE (x);
 	  if (x == 0)
diff --git a/gcc/calls.c b/gcc/calls.c
index bb12b0a1712..e31900f33ae 100644
--- a/gcc/calls.c
+++ b/gcc/calls.c
@@ -598,7 +598,7 @@ emit_call_1 (funexp, fndecl, funtype, stack_size, rounded_stack_size,
 
   /* If this is a const call, then set the insn's unchanging bit.  */
   if (ecf_flags & (ECF_CONST | ECF_PURE))
-    CONST_CALL_P (call_insn) = 1;
+    CONST_OR_PURE_CALL_P (call_insn) = 1;
 
   /* If this call can't throw, attach a REG_EH_REGION reg note to that
      effect.  */
diff --git a/gcc/cse.c b/gcc/cse.c
index c7d1fccdaa1..ade5b802c77 100644
--- a/gcc/cse.c
+++ b/gcc/cse.c
@@ -5956,7 +5956,7 @@ cse_insn (insn, libcall_insn)
 
   if (GET_CODE (insn) == CALL_INSN)
     {
-      if (! CONST_CALL_P (insn))
+      if (! CONST_OR_PURE_CALL_P (insn))
 	invalidate_memory ();
       invalidate_for_call ();
     }
@@ -6636,7 +6636,7 @@ invalidate_skipped_block (start)
 
       if (GET_CODE (insn) == CALL_INSN)
 	{
-	  if (! CONST_CALL_P (insn))
+	  if (! CONST_OR_PURE_CALL_P (insn))
 	    invalidate_memory ();
 	  invalidate_for_call ();
 	}
diff --git a/gcc/cselib.c b/gcc/cselib.c
index e8e6beb5bd2..e6d5b2ae50f 100644
--- a/gcc/cselib.c
+++ b/gcc/cselib.c
@@ -1279,7 +1279,7 @@ cselib_process_insn (insn)
 	if (call_used_regs[i])
 	  cselib_invalidate_regno (i, VOIDmode);
 
-      if (! CONST_CALL_P (insn))
+      if (! CONST_OR_PURE_CALL_P (insn))
 	cselib_invalidate_mem (callmem);
     }
 
diff --git a/gcc/df.c b/gcc/df.c
index 52fa3629e55..776f4feebc8 100644
--- a/gcc/df.c
+++ b/gcc/df.c
@@ -2882,7 +2882,7 @@ df_insns_modify (df, bb, first_insn, last_insn)
 	 it does, we need to create a new basic block.  Ouch.  The
 	 same applies for a label.  */
       if ((GET_CODE (insn) == CALL_INSN
-	   && ! CONST_CALL_P (insn))
+	   && ! CONST_OR_PURE_CALL_P (insn))
 	  || GET_CODE (insn) == CODE_LABEL)
 	abort ();
 
diff --git a/gcc/flow.c b/gcc/flow.c
index c01d56ff47f..b2c90877e23 100644
--- a/gcc/flow.c
+++ b/gcc/flow.c
@@ -2512,7 +2512,8 @@ need_fake_edge_p (insn)
 
   if ((GET_CODE (insn) == CALL_INSN
        && !SIBLING_CALL_P (insn)
-       && !find_reg_note (insn, REG_NORETURN, NULL) && !CONST_CALL_P (insn)))
+       && !find_reg_note (insn, REG_NORETURN, NULL)
+       && !CONST_OR_PURE_CALL_P (insn)))
     return true;
 
   return ((GET_CODE (PATTERN (insn)) == ASM_OPERANDS
@@ -5392,7 +5393,7 @@ propagate_one_insn (pbi, insn)
 	    cond = COND_EXEC_TEST (PATTERN (insn));
 
 	  /* Non-constant calls clobber memory.  */
-	  if (! CONST_CALL_P (insn))
+	  if (! CONST_OR_PURE_CALL_P (insn))
 	    {
 	      free_EXPR_LIST_list (&pbi->mem_set_list);
 	      pbi->mem_set_list_len = 0;
diff --git a/gcc/gcse.c b/gcc/gcse.c
index 4fe1b3be601..f0031c093fe 100644
--- a/gcc/gcse.c
+++ b/gcc/gcse.c
@@ -2514,8 +2514,7 @@ compute_hash_table (set_p)
 		if (TEST_HARD_REG_BIT (regs_invalidated_by_call, regno))
 		  record_last_reg_set_info (insn, regno);
 
-	      if (! CONST_CALL_P (insn))
-		record_last_mem_set_info (insn);
+	      mark_call (insn);
 	    }
 
 	  note_stores (PATTERN (insn), record_last_set_info, insn);
@@ -2794,7 +2793,7 @@ static void
 mark_call (insn)
      rtx insn;
 {
-  if (! CONST_CALL_P (insn))
+  if (! CONST_OR_PURE_CALL_P (insn))
     record_last_mem_set_info (insn);
 }
 
@@ -6478,6 +6477,9 @@ find_loads (x, store_pattern)
   int i,j;
   int ret = 0;
 
+  if (!x)
+    return 0;
+
   if (GET_CODE (x) == SET) 
     x = SET_SRC (x);
 
@@ -6513,7 +6515,7 @@ store_killed_in_insn (x, insn)
   
   if (GET_CODE (insn) == CALL_INSN)
     {
-      if (CONST_CALL_P (insn))
+      if (CONST_OR_PURE_CALL_P (insn))
 	return 0;
       else
 	return 1;
diff --git a/gcc/haifa-sched.c b/gcc/haifa-sched.c
index 4974c22f686..c8fb5f767d6 100644
--- a/gcc/haifa-sched.c
+++ b/gcc/haifa-sched.c
@@ -1561,7 +1561,7 @@ reemit_notes (insn, last)
 	  if (note_type == NOTE_INSN_SETJMP)
 	    {
 	      retval = emit_note_after (NOTE_INSN_SETJMP, insn);
-	      CONST_CALL_P (retval) = CONST_CALL_P (note);
+	      CONST_OR_PURE_CALL_P (retval) = CONST_OR_PURE_CALL_P (note);
 	      remove_note (insn, note);
 	      note = XEXP (note, 1);
 	    }
diff --git a/gcc/integrate.c b/gcc/integrate.c
index 83d3819b832..29c68094140 100644
--- a/gcc/integrate.c
+++ b/gcc/integrate.c
@@ -1522,7 +1522,7 @@ copy_insn_list (insns, map, static_chain_value)
 	  copy = emit_call_insn (pattern);
 
 	  SIBLING_CALL_P (copy) = SIBLING_CALL_P (insn);
-	  CONST_CALL_P (copy) = CONST_CALL_P (insn);
+	  CONST_OR_PURE_CALL_P (copy) = CONST_OR_PURE_CALL_P (insn);
 
 	  /* Because the USAGE information potentially contains objects other
 	     than hard registers, we need to copy it.  */
diff --git a/gcc/jump.c b/gcc/jump.c
index dd099f2a840..9099c1f5c3a 100644
--- a/gcc/jump.c
+++ b/gcc/jump.c
@@ -1521,7 +1521,7 @@ delete_prior_computation (note, insn)
       /* If we reach a CALL which is not calling a const function
 	 or the callee pops the arguments, then give up.  */
       if (GET_CODE (our_prev) == CALL_INSN
-	  && (! CONST_CALL_P (our_prev)
+	  && (! CONST_OR_PURE_CALL_P (our_prev)
 	      || GET_CODE (pat) != SET || GET_CODE (SET_SRC (pat)) != CALL))
 	break;
 
diff --git a/gcc/local-alloc.c b/gcc/local-alloc.c
index efc31597908..8dd3174c83d 100644
--- a/gcc/local-alloc.c
+++ b/gcc/local-alloc.c
@@ -499,7 +499,7 @@ validate_equiv_mem (start, reg, memref)
 	return 1;
 
       if (GET_CODE (insn) == CALL_INSN && ! RTX_UNCHANGING_P (memref)
-	  && ! CONST_CALL_P (insn))
+	  && ! CONST_OR_PURE_CALL_P (insn))
 	return 0;
 
       note_stores (PATTERN (insn), validate_equiv_mem_from_store, NULL);
diff --git a/gcc/loop.c b/gcc/loop.c
index fbbef734b7c..50b430d7cd8 100644
--- a/gcc/loop.c
+++ b/gcc/loop.c
@@ -950,7 +950,7 @@ scan_loop (loop, flags)
       /* Past a call insn, we get to insns which might not be executed
 	 because the call might exit.  This matters for insns that trap.
 	 Constant and pure call insns always return, so they don't count.  */
-      else if (GET_CODE (p) == CALL_INSN && ! CONST_CALL_P (p))
+      else if (GET_CODE (p) == CALL_INSN && ! CONST_OR_PURE_CALL_P (p))
 	call_passed = 1;
       /* Past a label or a jump, we get to insns for which we
 	 can't count on whether or how many times they will be
@@ -2364,7 +2364,7 @@ prescan_loop (loop)
 	}
       else if (GET_CODE (insn) == CALL_INSN)
 	{
-	  if (! CONST_CALL_P (insn))
+	  if (! CONST_OR_PURE_CALL_P (insn))
 	    {
 	      loop_info->unknown_address_altered = 1;
 	      loop_info->has_nonconst_call = 1;
diff --git a/gcc/predict.c b/gcc/predict.c
index 36f59e0c0ae..91a64a3fd1f 100644
--- a/gcc/predict.c
+++ b/gcc/predict.c
@@ -386,7 +386,7 @@ estimate_probability (loops_info)
 		if (GET_CODE (insn) == CALL_INSN
 		    /* Constant and pure calls are hardly used to signalize
 		       something exceptional.  */
-		    && ! CONST_CALL_P (insn))
+		    && ! CONST_OR_PURE_CALL_P (insn))
 		  {
 		    predict_edge_def (e, PRED_CALL, NOT_TAKEN);
 		    break;
diff --git a/gcc/reload1.c b/gcc/reload1.c
index b2131de22e0..86b635429b9 100644
--- a/gcc/reload1.c
+++ b/gcc/reload1.c
@@ -762,7 +762,7 @@ reload (first, global)
     {
       rtx set = single_set (insn);
 
-      if (GET_CODE (insn) == NOTE && CONST_CALL_P (insn)
+      if (GET_CODE (insn) == NOTE && CONST_OR_PURE_CALL_P (insn)
 	  && NOTE_LINE_NUMBER (insn) == NOTE_INSN_SETJMP)
 	for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
 	  if (! call_used_regs[i])
diff --git a/gcc/rtl.h b/gcc/rtl.h
index 3a97da30545..9e707dade0c 100644
--- a/gcc/rtl.h
+++ b/gcc/rtl.h
@@ -393,8 +393,8 @@ extern void rtvec_check_failed_bounds PARAMS ((rtvec, int,
 /* 1 if insn has been deleted.  */
 #define INSN_DELETED_P(INSN) ((INSN)->volatil)
 
-/* 1 if insn is a call to a const function.  */
-#define CONST_CALL_P(INSN) ((INSN)->unchanging)
+/* 1 if insn is a call to a const or pure function.  */
+#define CONST_OR_PURE_CALL_P(INSN) ((INSN)->unchanging)
 
 /* 1 if insn (assumed to be a CALL_INSN) is a sibling call.  */
 #define SIBLING_CALL_P(INSN) ((INSN)->jump)
diff --git a/gcc/sched-deps.c b/gcc/sched-deps.c
index 3f4b1290d7c..69397a9542c 100644
--- a/gcc/sched-deps.c
+++ b/gcc/sched-deps.c
@@ -1343,7 +1343,7 @@ sched_analyze (deps, head, tail)
 	     all pending reads and writes, and start new dependencies starting
 	     from here.  But only flush writes for constant calls (which may
 	     be passed a pointer to something we haven't written yet).  */
-	  flush_pending_lists (deps, insn, CONST_CALL_P (insn));
+	  flush_pending_lists (deps, insn, CONST_OR_PURE_CALL_P (insn));
 
 	  /* Depend this function call (actually, the user of this
 	     function call) on all hard register clobberage.  */
@@ -1393,7 +1393,7 @@ sched_analyze (deps, head, tail)
 	  loop_notes = alloc_EXPR_LIST (REG_SAVE_NOTE,
 					GEN_INT (NOTE_LINE_NUMBER (insn)),
 					loop_notes);
-	  CONST_CALL_P (loop_notes) = CONST_CALL_P (insn);
+	  CONST_OR_PURE_CALL_P (loop_notes) = CONST_OR_PURE_CALL_P (insn);
 	}
 
       if (insn == tail)