From 4f5888905c9a368a6399031b7fcd92587e4a6524 Mon Sep 17 00:00:00 2001
From: "Kaveh R. Ghazi" <ghazi@caip.rutgers.edu>
Date: Mon, 30 Jul 2007 15:35:02 +0000
Subject: [PATCH] alias.c (mems_in_disjoint_alias_sets_p, [...]): Constify.

	* alias.c (mems_in_disjoint_alias_sets_p,
	fixed_scalar_and_varying_struct_p, aliases_everything_p,
	nonoverlapping_component_refs_p, nonoverlapping_memrefs_p,
	write_dependence_p, mems_in_disjoint_alias_sets_p,
	read_dependence, true_dependence, canon_true_dependence,
	anti_dependence, output_dependence): Constify.
	* combine.c (extended_count): Likewise.
	* cse.c (cse_rtx_varies_p, hash_rtx, exp_equiv_p): Likewise.
	* cselib.c (get_value_hash, references_value_p,
	cselib_reg_set_mode, cselib_rtx_varies_p): Likewise.
	* cselib.h (cselib_reg_set_mode, references_value_p): Likewise.
	* emit-rtl.c (mem_expr_equal_p, active_insn_p): Likewise.
	* function.c (contains, prologue_epilogue_contains,
	sibcall_epilogue_contains): Likewise.
	* jump.c (simplejump_p, condjump_p, condjump_in_parallel_p,
	pc_set, any_uncondjump_p, any_condjump_p, onlyjump_p,
	only_sets_cc0_p, sets_cc0_p, rtx_renumbered_equal_p, true_regnum,
	reg_or_subregno): Likewise.
	* recog.c (asm_noperands): Likewise.
	* reload1.c (function_invariant_p): Likewise.
	* rtl.h (mem_expr_equal_p, active_insn_p, rtx_varies_p,
	rtx_addr_varies_p, asm_noperands, exp_equiv_p, hash_rtx,
	condjump_p, any_condjump_p, any_uncondjump_p, pc_set,
	simplejump_p, onlyjump_p, only_sets_cc0_p, sets_cc0_p,
	true_regnum, reg_or_subregno, condjump_in_parallel_p,
	extended_count, prologue_epilogue_contains,
	sibcall_epilogue_contains, function_invariant_p, true_dependence,
	canon_true_dependence, read_dependence, anti_dependence,
	output_dependence): Likewise.
	* rtlanal.c (rtx_varies_p, rtx_addr_varies_p): Likewise.

java:
	* jcf-io.c (find_class): Fix -Wcast-qual warnings.

From-SVN: r127063
---
 gcc/ChangeLog      | 33 +++++++++++++++++++++++++++
 gcc/alias.c        | 48 +++++++++++++++++++--------------------
 gcc/combine.c      |  2 +-
 gcc/cse.c          | 10 ++++-----
 gcc/cselib.c       | 12 +++++-----
 gcc/cselib.h       |  4 ++--
 gcc/emit-rtl.c     |  4 ++--
 gcc/function.c     |  8 +++----
 gcc/java/ChangeLog |  4 ++++
 gcc/java/jcf-io.c  | 13 ++++++-----
 gcc/jump.c         | 32 +++++++++++++-------------
 gcc/recog.c        |  2 +-
 gcc/reload1.c      |  2 +-
 gcc/rtl.h          | 56 +++++++++++++++++++++++-----------------------
 gcc/rtlanal.c      |  8 +++----
 15 files changed, 139 insertions(+), 99 deletions(-)

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index e8aff1eeef4..aa6f96f67db 100644
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,36 @@
+2007-07-30  Kaveh R. Ghazi  <ghazi@caip.rutgers.edu>
+
+	* alias.c (mems_in_disjoint_alias_sets_p,
+	fixed_scalar_and_varying_struct_p, aliases_everything_p,
+	nonoverlapping_component_refs_p, nonoverlapping_memrefs_p,
+	write_dependence_p, mems_in_disjoint_alias_sets_p,
+	read_dependence, true_dependence, canon_true_dependence,
+	anti_dependence, output_dependence): Constify.
+	* combine.c (extended_count): Likewise.
+	* cse.c (cse_rtx_varies_p, hash_rtx, exp_equiv_p): Likewise.
+	* cselib.c (get_value_hash, references_value_p,
+	cselib_reg_set_mode, cselib_rtx_varies_p): Likewise.
+	* cselib.h (cselib_reg_set_mode, references_value_p): Likewise.
+	* emit-rtl.c (mem_expr_equal_p, active_insn_p): Likewise.
+	* function.c (contains, prologue_epilogue_contains,
+	sibcall_epilogue_contains): Likewise. 
+	* jump.c (simplejump_p, condjump_p, condjump_in_parallel_p,
+	pc_set, any_uncondjump_p, any_condjump_p, onlyjump_p,
+	only_sets_cc0_p, sets_cc0_p, rtx_renumbered_equal_p, true_regnum,
+	reg_or_subregno): Likewise.
+	* recog.c (asm_noperands): Likewise.
+	* reload1.c (function_invariant_p): Likewise.
+	* rtl.h (mem_expr_equal_p, active_insn_p, rtx_varies_p,
+	rtx_addr_varies_p, asm_noperands, exp_equiv_p, hash_rtx,
+	condjump_p, any_condjump_p, any_uncondjump_p, pc_set,
+	simplejump_p, onlyjump_p, only_sets_cc0_p, sets_cc0_p,
+	true_regnum, reg_or_subregno, condjump_in_parallel_p,
+	extended_count, prologue_epilogue_contains,
+	sibcall_epilogue_contains, function_invariant_p, true_dependence,
+	canon_true_dependence, read_dependence, anti_dependence,
+	output_dependence): Likewise.
+	* rtlanal.c (rtx_varies_p, rtx_addr_varies_p): Likewise.
+
 2007-07-30  Julian Brown  <julian@codesourcery.com>
 
 	* config/arm/neon.md (V_ext): New mode attribute.
diff --git a/gcc/alias.c b/gcc/alias.c
index 1d008b4dcac..a87b4c85be8 100644
--- a/gcc/alias.c
+++ b/gcc/alias.c
@@ -154,18 +154,18 @@ static void record_set (rtx, rtx, void *);
 static int base_alias_check (rtx, rtx, enum machine_mode,
 			     enum machine_mode);
 static rtx find_base_value (rtx);
-static int mems_in_disjoint_alias_sets_p (rtx, rtx);
+static int mems_in_disjoint_alias_sets_p (const_rtx, const_rtx);
 static int insert_subset_children (splay_tree_node, void*);
 static tree find_base_decl (tree);
 static alias_set_entry get_alias_set_entry (HOST_WIDE_INT);
-static rtx fixed_scalar_and_varying_struct_p (rtx, rtx, rtx, rtx,
-					      int (*) (rtx, int));
-static int aliases_everything_p (rtx);
-static bool nonoverlapping_component_refs_p (tree, tree);
+static const_rtx fixed_scalar_and_varying_struct_p (const_rtx, const_rtx, rtx, rtx,
+						    bool (*) (const_rtx, bool));
+static int aliases_everything_p (const_rtx);
+static bool nonoverlapping_component_refs_p (const_tree, const_tree);
 static tree decl_for_component_ref (tree);
 static rtx adjust_offset_for_component_ref (tree, rtx);
-static int nonoverlapping_memrefs_p (rtx, rtx);
-static int write_dependence_p (rtx, rtx, int);
+static int nonoverlapping_memrefs_p (const_rtx, const_rtx);
+static int write_dependence_p (const_rtx, const_rtx, int);
 
 static void memory_modified_1 (rtx, rtx, void *);
 static void record_alias_subset (HOST_WIDE_INT, HOST_WIDE_INT);
@@ -266,7 +266,7 @@ get_alias_set_entry (HOST_WIDE_INT alias_set)
    the two MEMs cannot alias each other.  */
 
 static inline int
-mems_in_disjoint_alias_sets_p (rtx mem1, rtx mem2)
+mems_in_disjoint_alias_sets_p (const_rtx mem1, const_rtx mem2)
 {
 /* Perform a basic sanity check.  Namely, that there are no alias sets
    if we're not using strict aliasing.  This helps to catch bugs
@@ -1803,7 +1803,7 @@ memrefs_conflict_p (int xsize, rtx x, int ysize, rtx y, HOST_WIDE_INT c)
    only be a dependence here if both reads are volatile.  */
 
 int
-read_dependence (rtx mem, rtx x)
+read_dependence (const_rtx mem, const_rtx x)
 {
   return MEM_VOLATILE_P (x) && MEM_VOLATILE_P (mem);
 }
@@ -1816,10 +1816,10 @@ read_dependence (rtx mem, rtx x)
    nonzero whenever variation is possible.
    MEM1_ADDR and MEM2_ADDR are the addresses of MEM1 and MEM2.  */
 
-static rtx
-fixed_scalar_and_varying_struct_p (rtx mem1, rtx mem2, rtx mem1_addr,
+static const_rtx
+fixed_scalar_and_varying_struct_p (const_rtx mem1, const_rtx mem2, rtx mem1_addr,
 				   rtx mem2_addr,
-				   int (*varies_p) (rtx, int))
+				   bool (*varies_p) (const_rtx, bool))
 {
   if (! flag_strict_aliasing)
     return NULL_RTX;
@@ -1845,7 +1845,7 @@ fixed_scalar_and_varying_struct_p (rtx mem1, rtx mem2, rtx mem1_addr,
    indicates that it might well alias *anything*.  */
 
 static int
-aliases_everything_p (rtx mem)
+aliases_everything_p (const_rtx mem)
 {
   if (GET_CODE (XEXP (mem, 0)) == AND)
     /* If the address is an AND, it's very hard to know at what it is
@@ -1859,9 +1859,9 @@ aliases_everything_p (rtx mem)
    overlap for any pair of objects.  */
 
 static bool
-nonoverlapping_component_refs_p (tree x, tree y)
+nonoverlapping_component_refs_p (const_tree x, const_tree y)
 {
-  tree fieldx, fieldy, typex, typey, orig_y;
+  const_tree fieldx, fieldy, typex, typey, orig_y;
 
   do
     {
@@ -1959,7 +1959,7 @@ adjust_offset_for_component_ref (tree x, rtx offset)
    X and Y and they do not overlap.  */
 
 static int
-nonoverlapping_memrefs_p (rtx x, rtx y)
+nonoverlapping_memrefs_p (const_rtx x, const_rtx y)
 {
   tree exprx = MEM_EXPR (x), expry = MEM_EXPR (y);
   rtx rtlx, rtly;
@@ -2108,8 +2108,8 @@ nonoverlapping_memrefs_p (rtx x, rtx y)
 /* True dependence: X is read after store in MEM takes place.  */
 
 int
-true_dependence (rtx mem, enum machine_mode mem_mode, rtx x,
-		 int (*varies) (rtx, int))
+true_dependence (const_rtx mem, enum machine_mode mem_mode, const_rtx x,
+		 bool (*varies) (const_rtx, bool))
 {
   rtx x_addr, mem_addr;
   rtx base;
@@ -2185,8 +2185,8 @@ true_dependence (rtx mem, enum machine_mode mem_mode, rtx x,
    this value prior to canonicalizing.  */
 
 int
-canon_true_dependence (rtx mem, enum machine_mode mem_mode, rtx mem_addr,
-		       rtx x, int (*varies) (rtx, int))
+canon_true_dependence (const_rtx mem, enum machine_mode mem_mode, rtx mem_addr,
+		       const_rtx x, bool (*varies) (const_rtx, bool))
 {
   rtx x_addr;
 
@@ -2246,10 +2246,10 @@ canon_true_dependence (rtx mem, enum machine_mode mem_mode, rtx mem_addr,
    (or, if WRITEP is nonzero, a write to) MEM.  */
 
 static int
-write_dependence_p (rtx mem, rtx x, int writep)
+write_dependence_p (const_rtx mem, const_rtx x, int writep)
 {
   rtx x_addr, mem_addr;
-  rtx fixed_scalar;
+  const_rtx fixed_scalar;
   rtx base;
 
   if (MEM_VOLATILE_P (x) && MEM_VOLATILE_P (mem))
@@ -2309,7 +2309,7 @@ write_dependence_p (rtx mem, rtx x, int writep)
 /* Anti dependence: X is written after read in MEM takes place.  */
 
 int
-anti_dependence (rtx mem, rtx x)
+anti_dependence (const_rtx mem, const_rtx x)
 {
   return write_dependence_p (mem, x, /*writep=*/0);
 }
@@ -2317,7 +2317,7 @@ anti_dependence (rtx mem, rtx x)
 /* Output dependence: X is written after store in MEM takes place.  */
 
 int
-output_dependence (rtx mem, rtx x)
+output_dependence (const_rtx mem, const_rtx x)
 {
   return write_dependence_p (mem, x, /*writep=*/1);
 }
diff --git a/gcc/combine.c b/gcc/combine.c
index dda1a5b0152..dab7453c9c4 100644
--- a/gcc/combine.c
+++ b/gcc/combine.c
@@ -8748,7 +8748,7 @@ reg_num_sign_bit_copies_for_combine (const_rtx x, enum machine_mode mode,
    implies that it must be called from a define_split.  */
 
 unsigned int
-extended_count (rtx x, enum machine_mode mode, int unsignedp)
+extended_count (const_rtx x, enum machine_mode mode, int unsignedp)
 {
   if (nonzero_sign_valid == 0)
     return 0;
diff --git a/gcc/cse.c b/gcc/cse.c
index fe06109cf24..6c2530ac612 100644
--- a/gcc/cse.c
+++ b/gcc/cse.c
@@ -558,7 +558,7 @@ static struct table_elt *insert (rtx, struct table_elt *, unsigned,
 				 enum machine_mode);
 static void merge_equiv_classes (struct table_elt *, struct table_elt *);
 static void invalidate (rtx, enum machine_mode);
-static int cse_rtx_varies_p (rtx, int);
+static bool cse_rtx_varies_p (const_rtx, bool);
 static void remove_invalid_refs (unsigned int);
 static void remove_invalid_subreg_refs (unsigned int, unsigned int,
 					enum machine_mode);
@@ -2059,7 +2059,7 @@ hash_rtx_string (const char *ps)
    is just (int) MEM plus the hash code of the address.  */
 
 unsigned
-hash_rtx (rtx x, enum machine_mode mode, int *do_not_record_p,
+hash_rtx (const_rtx x, enum machine_mode mode, int *do_not_record_p,
 	  int *hash_arg_in_memory_p, bool have_reg_qty)
 {
   int i, j;
@@ -2373,7 +2373,7 @@ safe_hash (rtx x, enum machine_mode mode)
    If FOR_GCSE is true, we compare X and Y for equivalence for GCSE.  */
 
 int
-exp_equiv_p (rtx x, rtx y, int validate, bool for_gcse)
+exp_equiv_p (const_rtx x, const_rtx y, int validate, bool for_gcse)
 {
   int i, j;
   enum rtx_code code;
@@ -2565,8 +2565,8 @@ exp_equiv_p (rtx x, rtx y, int validate, bool for_gcse)
    executions of the program.  0 means X can be compared reliably
    against certain constants or near-constants.  */
 
-static int
-cse_rtx_varies_p (rtx x, int from_alias)
+static bool
+cse_rtx_varies_p (const_rtx x, bool from_alias)
 {
   /* We need not check for X and the equivalence class being of the same
      mode because if X is equivalent to a constant in some mode, it
diff --git a/gcc/cselib.c b/gcc/cselib.c
index 1561762c931..41f0da627db 100644
--- a/gcc/cselib.c
+++ b/gcc/cselib.c
@@ -265,7 +265,7 @@ entry_and_rtx_equal_p (const void *entry, const void *x_arg)
 static hashval_t
 get_value_hash (const void *entry)
 {
-  const cselib_val *v = (const cselib_val *) entry;
+  const cselib_val *const v = (const cselib_val *) entry;
   return v->value;
 }
 
@@ -275,9 +275,9 @@ get_value_hash (const void *entry)
    removed.  */
 
 int
-references_value_p (rtx x, int only_useless)
+references_value_p (const_rtx x, int only_useless)
 {
-  enum rtx_code code = GET_CODE (x);
+  const enum rtx_code code = GET_CODE (x);
   const char *fmt = GET_RTX_FORMAT (code);
   int i, j;
 
@@ -384,7 +384,7 @@ remove_useless_values (void)
    VOIDmode.  */
 
 enum machine_mode
-cselib_reg_set_mode (rtx x)
+cselib_reg_set_mode (const_rtx x)
 {
   if (!REG_P (x))
     return GET_MODE (x);
@@ -1354,8 +1354,8 @@ cselib_invalidate_regno (unsigned int regno, enum machine_mode mode)
    executions of the program.  0 means X can be compared reliably
    against certain constants or near-constants.  */
 
-static int
-cselib_rtx_varies_p (rtx x ATTRIBUTE_UNUSED, int from_alias ATTRIBUTE_UNUSED)
+static bool
+cselib_rtx_varies_p (const_rtx x ATTRIBUTE_UNUSED, bool from_alias ATTRIBUTE_UNUSED)
 {
   /* We actually don't need to verify very hard.  This is because
      if X has actually changed, we invalidate the memory anyway,
diff --git a/gcc/cselib.h b/gcc/cselib.h
index e82696fea19..0e4c6f211df 100644
--- a/gcc/cselib.h
+++ b/gcc/cselib.h
@@ -65,9 +65,9 @@ extern void cselib_init (bool record_memory);
 extern void cselib_clear_table (void);
 extern void cselib_finish (void);
 extern void cselib_process_insn (rtx);
-extern enum machine_mode cselib_reg_set_mode (rtx);
+extern enum machine_mode cselib_reg_set_mode (const_rtx);
 extern int rtx_equal_for_cselib_p (rtx, rtx);
-extern int references_value_p (rtx, int);
+extern int references_value_p (const_rtx, int);
 extern rtx cselib_expand_value_rtx (rtx, bitmap, int);
 extern rtx cselib_subst_to_values (rtx);
 extern void cselib_invalidate_rtx (rtx);
diff --git a/gcc/emit-rtl.c b/gcc/emit-rtl.c
index fbc74eb207c..3c6bf725e1c 100644
--- a/gcc/emit-rtl.c
+++ b/gcc/emit-rtl.c
@@ -1425,7 +1425,7 @@ component_ref_for_mem_expr (tree ref)
    and 0 otherwise.  */
 
 int
-mem_expr_equal_p (tree expr1, tree expr2)
+mem_expr_equal_p (const_tree expr1, const_tree expr2)
 {
   if (expr1 == expr2)
     return 1;
@@ -2904,7 +2904,7 @@ last_call_insn (void)
    same as next_real_insn.  */
 
 int
-active_insn_p (rtx insn)
+active_insn_p (const_rtx insn)
 {
   return (CALL_P (insn) || JUMP_P (insn)
 	  || (NONJUMP_INSN_P (insn)
diff --git a/gcc/function.c b/gcc/function.c
index eaeaeebc1a9..592f95343b4 100644
--- a/gcc/function.c
+++ b/gcc/function.c
@@ -202,7 +202,7 @@ extern tree debug_find_var_in_block_tree (tree, tree);
 /* We always define `record_insns' even if it's not used so that we
    can always export `prologue_epilogue_contains'.  */
 static void record_insns (rtx, VEC(int,heap) **) ATTRIBUTE_UNUSED;
-static int contains (rtx, VEC(int,heap) **);
+static int contains (const_rtx, VEC(int,heap) **);
 #ifdef HAVE_return
 static void emit_return_into_block (basic_block);
 #endif
@@ -4601,7 +4601,7 @@ set_insn_locators (rtx insn, int loc)
    be running after reorg, SEQUENCE rtl is possible.  */
 
 static int
-contains (rtx insn, VEC(int,heap) **vec)
+contains (const_rtx insn, VEC(int,heap) **vec)
 {
   int i, j;
 
@@ -4626,7 +4626,7 @@ contains (rtx insn, VEC(int,heap) **vec)
 }
 
 int
-prologue_epilogue_contains (rtx insn)
+prologue_epilogue_contains (const_rtx insn)
 {
   if (contains (insn, &prologue))
     return 1;
@@ -4636,7 +4636,7 @@ prologue_epilogue_contains (rtx insn)
 }
 
 int
-sibcall_epilogue_contains (rtx insn)
+sibcall_epilogue_contains (const_rtx insn)
 {
   if (sibcall_epilogue)
     return contains (insn, &sibcall_epilogue);
diff --git a/gcc/java/ChangeLog b/gcc/java/ChangeLog
index e7b05e7981a..46a597bc307 100644
--- a/gcc/java/ChangeLog
+++ b/gcc/java/ChangeLog
@@ -1,3 +1,7 @@
+2007-07-30  Kaveh R. Ghazi  <ghazi@caip.rutgers.edu>
+
+	* jcf-io.c (find_class): Fix -Wcast-qual warnings.
+
 2007-07-29  Kaveh R. Ghazi  <ghazi@caip.rutgers.edu>
 
 	* lang.c (java_get_callee_fndecl): Constify.
diff --git a/gcc/java/jcf-io.c b/gcc/java/jcf-io.c
index 3a5018ac728..0c45dd1d39d 100644
--- a/gcc/java/jcf-io.c
+++ b/gcc/java/jcf-io.c
@@ -541,14 +541,17 @@ find_class (const char *classname, int classname_length, JCF *jcf)
 
   /* Remember that this class could not be found so that we do not
      have to look again.  */
-  *htab_find_slot_with_hash (memoized_class_lookups, classname, hash, INSERT) 
-    = (void *) classname;
+  *(const void **)htab_find_slot_with_hash (memoized_class_lookups,
+					    classname, hash, INSERT)
+    = classname;
 
   return NULL;
  found:
-  buffer = (char *) open_class (buffer, jcf, fd, dep_file);
-  jcf->classname = xstrdup (classname);
-  return buffer;
+  {
+    const char *const tmp = open_class (buffer, jcf, fd, dep_file);
+    jcf->classname = xstrdup (classname);
+    return tmp;
+  }
 }
 
 void
diff --git a/gcc/jump.c b/gcc/jump.c
index 86338243e13..d83b0a55f8f 100644
--- a/gcc/jump.c
+++ b/gcc/jump.c
@@ -654,7 +654,7 @@ comparison_dominates_p (enum rtx_code code1, enum rtx_code code2)
 /* Return 1 if INSN is an unconditional jump and nothing else.  */
 
 int
-simplejump_p (rtx insn)
+simplejump_p (const_rtx insn)
 {
   return (JUMP_P (insn)
 	  && GET_CODE (PATTERN (insn)) == SET
@@ -669,9 +669,9 @@ simplejump_p (rtx insn)
    branch and compare insns.  Use any_condjump_p instead whenever possible.  */
 
 int
-condjump_p (rtx insn)
+condjump_p (const_rtx insn)
 {
-  rtx x = PATTERN (insn);
+  const_rtx x = PATTERN (insn);
 
   if (GET_CODE (x) != SET
       || GET_CODE (SET_DEST (x)) != PC)
@@ -697,9 +697,9 @@ condjump_p (rtx insn)
    branch and compare insns.  Use any_condjump_p instead whenever possible.  */
 
 int
-condjump_in_parallel_p (rtx insn)
+condjump_in_parallel_p (const_rtx insn)
 {
-  rtx x = PATTERN (insn);
+  const_rtx x = PATTERN (insn);
 
   if (GET_CODE (x) != PARALLEL)
     return 0;
@@ -728,7 +728,7 @@ condjump_in_parallel_p (rtx insn)
 /* Return set of PC, otherwise NULL.  */
 
 rtx
-pc_set (rtx insn)
+pc_set (const_rtx insn)
 {
   rtx pat;
   if (!JUMP_P (insn))
@@ -749,9 +749,9 @@ pc_set (rtx insn)
    possibly bundled inside a PARALLEL.  */
 
 int
-any_uncondjump_p (rtx insn)
+any_uncondjump_p (const_rtx insn)
 {
-  rtx x = pc_set (insn);
+  const_rtx x = pc_set (insn);
   if (!x)
     return 0;
   if (GET_CODE (SET_SRC (x)) != LABEL_REF)
@@ -769,9 +769,9 @@ any_uncondjump_p (rtx insn)
    Note that unlike condjump_p it returns false for unconditional jumps.  */
 
 int
-any_condjump_p (rtx insn)
+any_condjump_p (const_rtx insn)
 {
-  rtx x = pc_set (insn);
+  const_rtx x = pc_set (insn);
   enum rtx_code a, b;
 
   if (!x)
@@ -830,7 +830,7 @@ returnjump_p (rtx insn)
    nothing more.  */
 
 int
-onlyjump_p (rtx insn)
+onlyjump_p (const_rtx insn)
 {
   rtx set;
 
@@ -854,7 +854,7 @@ onlyjump_p (rtx insn)
    and has no side effects.  */
 
 int
-only_sets_cc0_p (rtx x)
+only_sets_cc0_p (const_rtx x)
 {
   if (! x)
     return 0;
@@ -871,7 +871,7 @@ only_sets_cc0_p (rtx x)
    but also does other things.  */
 
 int
-sets_cc0_p (rtx x)
+sets_cc0_p (const_rtx x)
 {
   if (! x)
     return 0;
@@ -1422,7 +1422,7 @@ int
 rtx_renumbered_equal_p (rtx x, rtx y)
 {
   int i;
-  enum rtx_code code = GET_CODE (x);
+  const enum rtx_code code = GET_CODE (x);
   const char *fmt;
 
   if (x == y)
@@ -1604,7 +1604,7 @@ rtx_renumbered_equal_p (rtx x, rtx y)
    return -1.  Any rtx is valid for X.  */
 
 int
-true_regnum (rtx x)
+true_regnum (const_rtx x)
 {
   if (REG_P (x))
     {
@@ -1629,7 +1629,7 @@ true_regnum (rtx x)
 
 /* Return regno of the register REG and handle subregs too.  */
 unsigned int
-reg_or_subregno (rtx reg)
+reg_or_subregno (const_rtx reg)
 {
   if (GET_CODE (reg) == SUBREG)
     reg = SUBREG_REG (reg);
diff --git a/gcc/recog.c b/gcc/recog.c
index 4b9de5fe83f..5692f4ef7e2 100644
--- a/gcc/recog.c
+++ b/gcc/recog.c
@@ -1279,7 +1279,7 @@ comparison_operator (rtx op, enum machine_mode mode)
    Otherwise return -1.  */
 
 int
-asm_noperands (rtx body)
+asm_noperands (const_rtx body)
 {
   switch (GET_CODE (body))
     {
diff --git a/gcc/reload1.c b/gcc/reload1.c
index 2424ca91cc6..0c770b55073 100644
--- a/gcc/reload1.c
+++ b/gcc/reload1.c
@@ -5323,7 +5323,7 @@ free_for_value_p (int regno, enum machine_mode mode, int opnum,
    memory.  */
 
 int
-function_invariant_p (rtx x)
+function_invariant_p (const_rtx x)
 {
   if (CONSTANT_P (x))
     return 1;
diff --git a/gcc/rtl.h b/gcc/rtl.h
index af39d0229ad..ed8d36da821 100644
--- a/gcc/rtl.h
+++ b/gcc/rtl.h
@@ -1458,7 +1458,7 @@ extern rtx emit_copy_of_insn_after (rtx, rtx);
 extern void set_reg_attrs_from_mem (rtx, rtx);
 extern void set_mem_attrs_from_reg (rtx, rtx);
 extern void set_reg_attrs_for_parm (rtx, rtx);
-extern int mem_expr_equal_p (tree, tree);
+extern int mem_expr_equal_p (const_tree, const_tree);
 
 /* In rtl.c */
 extern rtx rtx_alloc_stat (RTX_CODE MEM_STAT_DECL);
@@ -1582,7 +1582,7 @@ extern rtx prev_real_insn (rtx);
 extern rtx next_real_insn (rtx);
 extern rtx prev_active_insn (rtx);
 extern rtx next_active_insn (rtx);
-extern int active_insn_p (rtx);
+extern int active_insn_p (const_rtx);
 extern rtx prev_label (rtx);
 extern rtx next_label (rtx);
 extern rtx skip_consecutive_labels (rtx);
@@ -1677,8 +1677,8 @@ typedef struct replace_label_data
 extern int rtx_addr_can_trap_p (const_rtx);
 extern bool nonzero_address_p (const_rtx);
 extern int rtx_unstable_p (const_rtx);
-extern int rtx_varies_p (rtx, int);
-extern int rtx_addr_varies_p (rtx, int);
+extern bool rtx_varies_p (const_rtx, bool);
+extern bool rtx_addr_varies_p (const_rtx, bool);
 extern HOST_WIDE_INT get_integer_term (const_rtx);
 extern rtx get_related_value (const_rtx);
 extern bool offset_within_block_p (const_rtx, HOST_WIDE_INT);
@@ -1764,7 +1764,7 @@ rtx remove_list_elem (rtx, rtx *);
 extern void free_reg_info (void);
 
 /* recog.c */
-extern int asm_noperands (rtx);
+extern int asm_noperands (const_rtx);
 extern const char *decode_asm_operands (rtx, rtx *, rtx **, const char **,
 					enum machine_mode *, location_t *);
 
@@ -2001,26 +2001,26 @@ extern int rtx_to_tree_code (enum rtx_code);
 /* In cse.c */
 extern int delete_trivially_dead_insns (rtx, int);
 extern int cse_main (rtx, int);
-extern int exp_equiv_p (rtx, rtx, int, bool);
-extern unsigned hash_rtx (rtx x, enum machine_mode, int *, int *, bool);
+extern int exp_equiv_p (const_rtx, const_rtx, int, bool);
+extern unsigned hash_rtx (const_rtx x, enum machine_mode, int *, int *, bool);
 
 /* In jump.c */
 extern int comparison_dominates_p (enum rtx_code, enum rtx_code);
-extern int condjump_p (rtx);
-extern int any_condjump_p (rtx);
-extern int any_uncondjump_p (rtx);
-extern rtx pc_set (rtx);
+extern int condjump_p (const_rtx);
+extern int any_condjump_p (const_rtx);
+extern int any_uncondjump_p (const_rtx);
+extern rtx pc_set (const_rtx);
 extern rtx condjump_label (rtx);
-extern int simplejump_p (rtx);
+extern int simplejump_p (const_rtx);
 extern int returnjump_p (rtx);
-extern int onlyjump_p (rtx);
-extern int only_sets_cc0_p (rtx);
-extern int sets_cc0_p (rtx);
+extern int onlyjump_p (const_rtx);
+extern int only_sets_cc0_p (const_rtx);
+extern int sets_cc0_p (const_rtx);
 extern int invert_jump_1 (rtx, rtx);
 extern int invert_jump (rtx, rtx, int);
 extern int rtx_renumbered_equal_p (rtx, rtx);
-extern int true_regnum (rtx);
-extern unsigned int reg_or_subregno (rtx);
+extern int true_regnum (const_rtx);
+extern unsigned int reg_or_subregno (const_rtx);
 extern int redirect_jump_1 (rtx, rtx);
 extern void redirect_jump_2 (rtx, rtx, rtx, int, int);
 extern int redirect_jump (rtx, rtx, int);
@@ -2030,7 +2030,7 @@ extern enum rtx_code reversed_comparison_code (rtx, rtx);
 extern enum rtx_code reversed_comparison_code_parts (enum rtx_code, rtx,
 						     rtx, rtx);
 extern void delete_for_peephole (rtx, rtx);
-extern int condjump_in_parallel_p (rtx);
+extern int condjump_in_parallel_p (const_rtx);
 
 /* In emit-rtl.c.  */
 extern int max_reg_num (void);
@@ -2078,7 +2078,7 @@ extern bool validate_subreg (enum machine_mode, enum machine_mode,
 			     rtx, unsigned int);
 
 /* In combine.c  */
-extern unsigned int extended_count (rtx, enum machine_mode, int);
+extern unsigned int extended_count (const_rtx, enum machine_mode, int);
 extern rtx remove_death (unsigned int, rtx);
 extern void dump_combine_stats (FILE *);
 extern void dump_combine_total_stats (FILE *);
@@ -2114,8 +2114,8 @@ extern void print_inline_rtx (FILE *, const_rtx, int);
 
 /* In function.c */
 extern void reposition_prologue_and_epilogue_notes (void);
-extern int prologue_epilogue_contains (rtx);
-extern int sibcall_epilogue_contains (rtx);
+extern int prologue_epilogue_contains (const_rtx);
+extern int sibcall_epilogue_contains (const_rtx);
 extern void mark_temp_addr_taken (rtx);
 extern void update_temp_slot_address (rtx, rtx);
 
@@ -2178,7 +2178,7 @@ extern void dbr_schedule (rtx);
 extern void dump_local_alloc (FILE *);
 
 /* In reload1.c */
-extern int function_invariant_p (rtx);
+extern int function_invariant_p (const_rtx);
 
 /* In calls.c */
 enum libcall_type
@@ -2218,13 +2218,13 @@ extern int read_rtx_lineno;
 
 /* In alias.c */
 extern rtx canon_rtx (rtx);
-extern int true_dependence (rtx, enum machine_mode, rtx, int (*)(rtx, int));
+extern int true_dependence (const_rtx, enum machine_mode, const_rtx, bool (*)(const_rtx, bool));
 extern rtx get_addr (rtx);
-extern int canon_true_dependence (rtx, enum machine_mode, rtx, rtx,
-				  int (*)(rtx, int));
-extern int read_dependence (rtx, rtx);
-extern int anti_dependence (rtx, rtx);
-extern int output_dependence (rtx, rtx);
+extern int canon_true_dependence (const_rtx, enum machine_mode, rtx, const_rtx,
+				  bool (*)(const_rtx, bool));
+extern int read_dependence (const_rtx, const_rtx);
+extern int anti_dependence (const_rtx, const_rtx);
+extern int output_dependence (const_rtx, const_rtx);
 extern void init_alias_once (void);
 extern void init_alias_analysis (void);
 extern void end_alias_analysis (void);
diff --git a/gcc/rtlanal.c b/gcc/rtlanal.c
index 9f88a5014e9..e4f51873fa1 100644
--- a/gcc/rtlanal.c
+++ b/gcc/rtlanal.c
@@ -175,8 +175,8 @@ rtx_unstable_p (const_rtx x)
    zero, we are slightly more conservative.
    The frame pointer and the arg pointer are considered constant.  */
 
-int
-rtx_varies_p (rtx x, int for_alias)
+bool
+rtx_varies_p (const_rtx x, bool for_alias)
 {
   RTX_CODE code;
   int i;
@@ -427,8 +427,8 @@ nonzero_address_p (const_rtx x)
    FOR_ALIAS is nonzero if we are called from alias analysis; if it is
    zero, we are slightly more conservative.  */
 
-int
-rtx_addr_varies_p (rtx x, int for_alias)
+bool
+rtx_addr_varies_p (const_rtx x, bool for_alias)
 {
   enum rtx_code code;
   int i;