alias.c (record_set, [...]): Use REG_P.

2004-06-15  Jerry Quinn  <jlquinn@optonline.net>

	* alias.c (record_set, record_base_value, canon_rtx, get_addr,
	nonlocal_mentioned_p_1, init_alias_analysis): Use REG_P.
	* bt-load.c (find_btr_reference, insn_sets_btr_p, note_btr_set):
	Likewise.
	* builtins.c (expand_builtin_setjmp, expand_builtin_apply,
	expand_builtin_mathfn, expand_builtin_strlen, expand_builtin_memcmp,
	expand_builtin_strcmp, expand_builtin_strncmp,
	expand_builtin_frame_address): Likewise.
	* caller-save.c (mark_set_regs, add_stored_regs, mark_referenced_regs,
	insert_one_insn): Likewise.
	* calls.c (prepare_call_address, precompute_register_parameters,
	precompute_arguments, expand_call, emit_library_call_value_1): Likewise.
	* cfganal.c (flow_active_insn_p): Likewise.
	* combine.c (set_nonzero_bits_and_sign_copies, can_combine_p,
	combinable_i3pat, try_combine, find_split_point, COMBINE_RTX_EQUAL_P,
	subst, combine_simplify_rtx, simplify_if_then_else, simplify_set,
	make_extraction, recog_for_combine, gen_lowpart_for_combine,
	simplify_comparison, record_dead_and_set_regs_1,
	record_dead_and_set_regs, record_promoted_value,
	check_promoted_subreg, get_last_value_validate, get_last_value,
	reg_dead_at_p_1, reg_bitfield_target_p, distribute_notes,
	unmentioned_reg_p_1): Likewise.
	* conflict.c (mark_reg): Likewise.
	* cse.c (HASH, COST, COST_IN, approx_reg_cost_1, notreg_cost,
	mention_regs, insert_regs, lookup, lookup_for_remove, insert,
	merge_equiv_classes, flush_hash_table, invalidate,
	remove_invalid_refs, remove_invalid_subreg_refs, rehash_using_reg,
	invalidate_for_call, use_related_value, canon_hash, exp_equiv_p,
	cse_rtx_varies_p, canon_reg, find_best_addr, fold_rtx, equiv_constant,
	record_jump_cond, cse_insn, addr_affects_sp_p,
	invalidate_from_clobbers, cse_process_notes, cse_around_loop,
	cse_set_around_loop, count_reg_usage, set_live_p, cse_change_cc_mode,
	cse_cc_succs, cse_condition_code_reg): Likewise.
	* cselib.c (cselib_reg_set_mode, rtx_equal_for_cselib_p,
	cselib_lookup, cselib_invalidate_regno, cselib_invalidate_rtx,
	cselib_record_set, cselib_record_sets): Likewise.
	* dbxout.c (dbxout_symbol_location, dbxout_parms, dbxout_reg_parms,
	dbxout_block): Likewise.
	* df.c (df_ref_record, df_def_record_1, df_uses_record): Likewise.
	* dojump.c (do_jump): Likewise.
	* dwarf2out.c (dwarf2out_frame_debug_expr, is_pseudo_reg,
	is_based_loc, rtl_for_decl_location): Likewise.
	* emit-rtl.c (set_reg_attrs_for_parm, set_decl_rtl,
	set_decl_incoming_rtl, mark_user_reg): Likewise.
	* explow.c (copy_all_regs, copy_all_regs, memory_address, force_reg,
	copy_to_suggested_reg, allocate_dynamic_stack_space,
	probe_stack_range, hard_function_value): Likewise.
	* expmed.c (store_bit_field, store_fixed_bit_field,
	store_split_bit_field, extract_bit_field, extract_fixed_bit_field,
	extract_split_bit_field, expand_divmod, emit_store_flag_force):
	Likewise.
	* expr.c (convert_move, convert_modes,
	block_move_libcall_safe_for_call_parm, emit_group_load, use_reg,
	use_group_regs, emit_move_insn, emit_move_insn_1,
	compress_float_constant, push_block, emit_single_push_insn,
	emit_push_insn, get_subtarget, expand_assignment, store_expr,
	store_constructor, store_field, force_operand, safe_from_p,
	expand_expr_real_1, expand_increment, do_store_flag, do_tablejump):
	Likewise.
	* final.c (profile_function, final_scan_insn, alter_subreg,
	get_mem_expr_from_op, output_asm_operand_names, output_operand,
	only_leaf_regs_used, leaf_renumber_regs_insn): Likewise.
	* flow.c (verify_wide_reg_1, mark_regs_live_at_end,
	find_regno_partial, propagate_one_insn, init_propagate_block_info,
	insn_dead_p, libcall_dead_p, mark_set_1, not_reg_cond,
	attempt_auto_inc, find_auto_inc, mark_used_regs,
	count_or_remove_death_notes_bb): Likewise.
	* function.c (find_temp_slot_from_address, update_temp_slot_address,
	preserve_temp_slots, put_var_into_stack, fixup_var_refs_insn,
	fixup_var_refs_1, fixup_stack_1, optimize_bit_field, flush_addressof,
	put_addressof_into_stack, purge_addressof_1, insns_for_mem_walk,
	purge_single_hard_subreg_set, instantiate_decl,
	instantiate_virtual_regs_1, aggregate_value_p, assign_parms,
	promoted_input_arg, setjmp_vars_warning, setjmp_args_warning,
	setjmp_protect, setjmp_protect_args, fix_lexical_addr,
	expand_function_start, diddle_return_value, clobber_return_register,
	expand_function_end, keep_stack_depressed, handle_epilogue_set,
	update_epilogue_consts): Likewise.
	* genemit.c (gen_exp, gen_insn): Likewise.
	* genrecog.c (make_insn_sequence): Likewise.
	* global.c (global_conflicts, expand_preferences, mark_reg_store,
	mark_reg_conflicts, set_preference, reg_becomes_live,
	build_insn_chain, mark_reg_change): Likewise.
	* haifa_sched.c (CONST_BASED_ADDRESS_P, find_set_reg_weight):
	Likewise.
	* ifcvt.c (noce_try_abs, noce_get_condition, noce_process_if_block):
	Likewise.
	* integrate.c (copy_rtx_and_substitute, try_constants,
	subst_constants, mark_stores, allocate_initial_values): Likewise.
	* jump.c (reversed_comparison_code_parts, delete_prior_computation,
	delete_computation, rtx_renumbered_equal_p, true_regnum,
	reg_or_subregno): Likewise.
	* lcm.c (reg_dies, reg_becomes_live): Likewise.
	* local-alloc.c (validate_equiv_mem_from_store, validate_equiv_mem,
	update_equiv_regs, no_equiv, block_alloc, combine_regs, reg_is_set,
	wipe_dead_reg, no_conflict_p): Likewise.
	* loop-iv.c (simple_reg_p, simple_set_p, kill_sets,
	iv_get_reaching_def, iv_analyze_biv, altered_reg_used, mark_altered,
	simple_rhs_p, simplify_using_assignment, implies_p): Likewise.
	* loop.c (scan_loop, combine_movables, rtx_equal_for_loop_p,
	move_movables, note_set_pseudo_multiple_uses, consec_sets_invariant_p,
	find_single_use_in_loop, count_one_set, loop_bivs_init_find,
	loop_givs_rescan, check_insn_for_bivs, check_insn_for_givs,
	valid_initial_value_p, simplify_giv_expr, consec_sets_giv,
	loop_regs_update, check_dbra_loop, maybe_eliminate_biv,
	maybe_eliminate_biv_1, record_initial, update_reg_last_use,
	canonicalize_condition, loop_regs_scan, load_mems, try_copy_prop,
	try_swap_copy_prop): Likewise.
	* optabs.c (expand_binop, expand_vector_binop, expand_vector_unop,
	expand_abs, emit_no_conflict_block, emit_libcall_block, expand_float):
	Likewise.
	* postreload.c (reload_cse_simplify, reload_cse_simplify_set,
	reload_cse_simplify_operands, reload_combine,
	reload_combine_note_store, reload_combine_note_use,
	reload_cse_move2add, move2add_note_store): Likewise.
	* print-rtl.c (print_rtx): Likewise.
	* ra-build.c (copy_insn_p, remember_move, init_one_web_common,
	contains_pseudo, handle_asm_insn): Likewise.
	* ra-debug.c (ra_print_rtx_object, dump_constraints,
	dump_static_insn_cost): Likewise.
	* ra-rewrite.c (slots_overlap_p, emit_colors,
	remove_suspicious_death_notes): Likewise.
	* recog.c (validate_replace_rtx_1, find_single_use_1, find_single_use,
	register_operand, scratch_operand, nonmemory_operand,
	constrain_operands): Likewise.
	* reg-stack (check_asm_stack_operands, remove_regno_note,
	emit_swap_insn, swap_rtx_condition, subst_stack_regs_pat,
	subst_asm_stack_regs): Likewise.
	* regclass.c (scan_one_insn, record_reg_classes, copy_cost,
	record_address_regs, reg_scan_mark_refs): Likewise.
	* regmove.c (discover_flags_reg, replacement_quality,
	copy_src_to_dest, reg_is_remote_constant_p, regmove_optimize,
	fixup_match_1): Likewise.
	* regrename.c (note_sets, clear_dead_regs, build_def_use, kill_value,
	kill_set_value, copyprop_hardreg_forward_1): Likewise.
	* reload.c (MATCHES, push_secondary_reload, find_reusable_reload,
	reload_inner_reg_of_subreg, can_reload_into, push_reload,
	combine_reloads, find_dummy_reload, hard_reg_set_here_p,
	operands_match_p, decompose, find_reloads, find_reloads_toplev,
	find_reloads_address, subst_indexed_address, find_reloads_address_1,
	find_reloads_subreg_address, find_replacement,
	refers_to_regno_for_reload_p, reg_overlap_mentioned_for_reload_p,
	refers_to_mem_for_reload_p, find_equiv_reg, regno_clobbered_p): Likewise.
	* reload1.c (replace_pseudos_in, reload, calculate_needs_all_insns,
	find_reg, delete_dead_insn, alter_reg, eliminate_regs,
	elimination_effects, eliminate_regs_in_insn, scan_paradoxical_subregs,
	forget_old_reloads_1, reload_reg_free_for_value_p, choose_reload_regs,
	emit_input_reload_insns, emit_output_reload_insns, do_input_reload,
	do_output_reload, emit_reload_insns, gen_reload,
	delete_address_reloads_1, inc_for_reload): Likewise.
	* reorg.c (update_reg_dead_notes, fix_reg_dead_note,
	update_reg_unused_notes, fill_slots_from_thread): Likewise.
	* resource.c (update_live_status, mark_referenced_resources,
	mark_set_resources, mark_target_live_regs): Likewise.
	* rtlanal.c (nonzero_address_p, get_jump_table_offset,
	global_reg_mentioned_p_1, reg_mentioned_p, reg_referenced_p,
	reg_set_p, set_noop_p, find_last_value, refers_to_regno_p,
	note_stores, dead_or_set_p, dead_or_set_regno_p, find_regno_note,
	find_reg_fusage, find_regno_fusage, replace_regs, regno_use_in,
	parms_set, find_first_parameter_load, keep_with_call_p,
	hoist_test_store, hoist_update_store, address_cost, nonzero_bits1,
	num_sign_bit_copies1): Likewise.
	* rtlhooks.c (gen_lowpart_general): Likewise.
	* sched-deps.c (deps_may_trap_p, sched_analyze_1, sched_analyze_insn,
	sched_analyze): Likewise.
	* sched-rgn.c (check_live_1, update_live_1, sets_likely_spilled_1):
	Likewise.
	* sdbout.c (sdbout_symbol, sdbout_parms, sdbout_reg_parms): Likewise.
	* simplify-rtx.c (simplify_replace_rtx, simplify_unary_operation,
	simplify_binary_operation, simplify_const_relational_operation,
	simplify_subreg): Likewise.
	* stmt.c (decl_conflicts_with_clobbers_p, expand_asm_operands,
	expand_end_stmt_expr, expand_return, expand_decl,
	expand_anon_union_decl): Likewise.
	* unroll.c (precondition_loop_p, calculate_giv_inc, copy_loop_body,
	find_splittable_regs, find_splittable_givs, find_common_reg_term,
	loop_iterations): Likewise.
	* var-tracking.c (variable_union, variable_part_different_p,
	variable_different_p, count_uses, add_uses, add_stores,
	compute_bb_dataflow, set_variable_part, delete_variable_part,
	emit_notes_in_bb, vt_get_decl_and_offset, vt_add_function_parameters):
	Likewise.
	* varasm.c (assemble_variable): Likewise.

From-SVN: r83195

1 files changed, 54 insertions, 54 deletions

diff --git a/gcc/function.c b/gcc/function.c
index 5554cbb..277ac76 100644
--- a/gcc/function.c
+++ b/gcc/function.c
@@ -1061,10 +1061,10 @@ find_temp_slot_from_address (rtx x)
 
   /* If we have a sum involving a register, see if it points to a temp
      slot.  */
-  if (GET_CODE (x) == PLUS && GET_CODE (XEXP (x, 0)) == REG
+  if (GET_CODE (x) == PLUS && REG_P (XEXP (x, 0))
       && (p = find_temp_slot_from_address (XEXP (x, 0))) != 0)
     return p;
-  else if (GET_CODE (x) == PLUS && GET_CODE (XEXP (x, 1)) == REG
+  else if (GET_CODE (x) == PLUS && REG_P (XEXP (x, 1))
 	   && (p = find_temp_slot_from_address (XEXP (x, 1))) != 0)
     return p;
 
@@ -1094,7 +1094,7 @@ update_temp_slot_address (rtx old, rtx new)
       if (GET_CODE (old) != PLUS)
 	return;
 
-      if (GET_CODE (new) == REG)
+      if (REG_P (new))
 	{
 	  update_temp_slot_address (XEXP (old, 0), new);
 	  update_temp_slot_address (XEXP (old, 1), new);
@@ -1181,7 +1181,7 @@ preserve_temp_slots (rtx x)
      a temporary slot we know it points to.  To be consistent with
      the code below, we really should preserve all non-kept slots
      if we can't find a match, but that seems to be much too costly.  */
-  if (GET_CODE (x) == REG && REG_POINTER (x))
+  if (REG_P (x) && REG_POINTER (x))
     p = find_temp_slot_from_address (x);
 
   /* If X is not in memory or is at a constant address, it cannot be in
@@ -1407,7 +1407,7 @@ put_var_into_stack (tree decl, int rescan)
      if the var is non-local.  */
   if (TREE_CODE (decl) != SAVE_EXPR && DECL_NONLOCAL (decl)
       && GET_CODE (reg) == MEM
-      && GET_CODE (XEXP (reg, 0)) == REG
+      && REG_P (XEXP (reg, 0))
       && REGNO (XEXP (reg, 0)) > LAST_VIRTUAL_REGISTER)
     {
       orig_reg = reg = XEXP (reg, 0);
@@ -1437,7 +1437,7 @@ put_var_into_stack (tree decl, int rescan)
 
   /* Now we should have a value that resides in one or more pseudo regs.  */
 
-  if (GET_CODE (reg) == REG)
+  if (REG_P (reg))
     {
       if (can_use_addressof_p)
 	gen_mem_addressof (reg, decl, rescan);
@@ -1761,7 +1761,7 @@ fixup_var_refs_insn (rtx insn, rtx var, enum machine_mode promoted_mode,
 	      don't delete the insn.  */
 	   && find_reg_note (insn, REG_RETVAL, NULL_RTX) == 0
 	   && (rtx_equal_p (SET_SRC (set), var)
-	       || (GET_CODE (SET_SRC (set)) == REG
+	       || (REG_P (SET_SRC (set))
 		   && (prev = prev_nonnote_insn (insn)) != 0
 		   && (prev_set = single_set (prev)) != 0
 		   && SET_DEST (prev_set) == SET_SRC (set)
@@ -1836,7 +1836,7 @@ fixup_var_refs_insn (rtx insn, rtx var, enum machine_mode promoted_mode,
 	{
 	  struct fixup_replacement *next;
 
-	  if (GET_CODE (replacements->new) == REG)
+	  if (REG_P (replacements->new))
 	    {
 	      rtx insert_before;
 	      rtx seq;
@@ -2351,9 +2351,9 @@ fixup_var_refs_1 (rtx var, enum machine_mode promoted_mode, rtx *loc, rtx insn,
 	if ((SET_SRC (x) == var
 	     || (GET_CODE (SET_SRC (x)) == SUBREG
 		 && SUBREG_REG (SET_SRC (x)) == var))
-	    && (GET_CODE (SET_DEST (x)) == REG
+	    && (REG_P (SET_DEST (x))
 		|| (GET_CODE (SET_DEST (x)) == SUBREG
-		    && GET_CODE (SUBREG_REG (SET_DEST (x))) == REG))
+		    && REG_P (SUBREG_REG (SET_DEST (x)))))
 	    && GET_MODE (var) == promoted_mode
 	    && x == single_set (insn))
 	  {
@@ -2422,9 +2422,9 @@ fixup_var_refs_1 (rtx var, enum machine_mode promoted_mode, rtx *loc, rtx insn,
 	if ((SET_DEST (x) == var
 	     || (GET_CODE (SET_DEST (x)) == SUBREG
 		 && SUBREG_REG (SET_DEST (x)) == var))
-	    && (GET_CODE (SET_SRC (x)) == REG
+	    && (REG_P (SET_SRC (x))
 		|| (GET_CODE (SET_SRC (x)) == SUBREG
-		    && GET_CODE (SUBREG_REG (SET_SRC (x))) == REG))
+		    && REG_P (SUBREG_REG (SET_SRC (x)))))
 	    && GET_MODE (var) == promoted_mode
 	    && x == single_set (insn))
 	  {
@@ -2635,7 +2635,7 @@ fixup_stack_1 (rtx x, rtx insn)
       /* If we have address of a stack slot but it's not valid
 	 (displacement is too large), compute the sum in a register.  */
       if (GET_CODE (ad) == PLUS
-	  && GET_CODE (XEXP (ad, 0)) == REG
+	  && REG_P (XEXP (ad, 0))
 	  && ((REGNO (XEXP (ad, 0)) >= FIRST_VIRTUAL_REGISTER
 	       && REGNO (XEXP (ad, 0)) <= LAST_VIRTUAL_REGISTER)
 	      || REGNO (XEXP (ad, 0)) == FRAME_POINTER_REGNUM
@@ -2717,7 +2717,7 @@ optimize_bit_field (rtx body, rtx insn, rtx *equiv_mem)
 
       if (GET_CODE (XEXP (bitfield, 0)) == MEM)
 	memref = XEXP (bitfield, 0);
-      else if (GET_CODE (XEXP (bitfield, 0)) == REG
+      else if (REG_P (XEXP (bitfield, 0))
 	       && equiv_mem != 0)
 	memref = equiv_mem[REGNO (XEXP (bitfield, 0))];
       else if (GET_CODE (XEXP (bitfield, 0)) == SUBREG
@@ -2725,7 +2725,7 @@ optimize_bit_field (rtx body, rtx insn, rtx *equiv_mem)
 	memref = SUBREG_REG (XEXP (bitfield, 0));
       else if (GET_CODE (XEXP (bitfield, 0)) == SUBREG
 	       && equiv_mem != 0
-	       && GET_CODE (SUBREG_REG (XEXP (bitfield, 0))) == REG)
+	       && REG_P (SUBREG_REG (XEXP (bitfield, 0))))
 	memref = equiv_mem[REGNO (SUBREG_REG (XEXP (bitfield, 0)))];
 
       if (memref
@@ -2962,7 +2962,7 @@ flush_addressof (tree decl)
       && DECL_RTL (decl) != 0
       && GET_CODE (DECL_RTL (decl)) == MEM
       && GET_CODE (XEXP (DECL_RTL (decl), 0)) == ADDRESSOF
-      && GET_CODE (XEXP (XEXP (DECL_RTL (decl), 0), 0)) == REG)
+      && REG_P (XEXP (XEXP (DECL_RTL (decl), 0), 0)))
     put_addressof_into_stack (XEXP (DECL_RTL (decl), 0), 0);
 }
 
@@ -2976,7 +2976,7 @@ put_addressof_into_stack (rtx r, htab_t ht)
 
   rtx reg = XEXP (r, 0);
 
-  if (GET_CODE (reg) != REG)
+  if (!REG_P (reg))
     abort ();
 
   decl = ADDRESSOF_DECL (r);
@@ -3071,7 +3071,7 @@ purge_addressof_1 (rtx *loc, rtx insn, int force, int store, int may_postpone,
       /* If SUB is a hard or virtual register, try it as a pseudo-register.
 	 Otherwise, perhaps SUB is an expression, so generate code to compute
 	 it.  */
-      if (GET_CODE (sub) == REG && REGNO (sub) <= LAST_VIRTUAL_REGISTER)
+      if (REG_P (sub) && REGNO (sub) <= LAST_VIRTUAL_REGISTER)
 	sub = copy_to_reg (sub);
       else
 	sub = force_operand (sub, NULL_RTX);
@@ -3092,10 +3092,10 @@ purge_addressof_1 (rtx *loc, rtx insn, int force, int store, int may_postpone,
 
       if (GET_CODE (sub) == MEM)
 	sub = adjust_address_nv (sub, GET_MODE (x), 0);
-      else if (GET_CODE (sub) == REG
+      else if (REG_P (sub)
 	       && (MEM_VOLATILE_P (x) || GET_MODE (x) == BLKmode))
 	;
-      else if (GET_CODE (sub) == REG && GET_MODE (x) != GET_MODE (sub))
+      else if (REG_P (sub) && GET_MODE (x) != GET_MODE (sub))
 	{
 	  int size_x, size_sub;
 
@@ -3133,7 +3133,7 @@ purge_addressof_1 (rtx *loc, rtx insn, int force, int store, int may_postpone,
 		    rtx z = XEXP (XEXP (tem, 1), 0);
 
 		    if (GET_MODE (x) == GET_MODE (z)
-			|| (GET_CODE (XEXP (XEXP (tem, 1), 0)) != REG
+			|| (!REG_P (XEXP (XEXP (tem, 1), 0))
 			    && GET_CODE (XEXP (XEXP (tem, 1), 0)) != SUBREG))
 		      abort ();
 
@@ -3298,7 +3298,7 @@ purge_addressof_1 (rtx *loc, rtx insn, int force, int store, int may_postpone,
 	{
 	  /* Remember the replacement so that the same one can be done
 	     on the REG_NOTES.  */
-	  if (GET_CODE (sub) == REG || GET_CODE (sub) == SUBREG)
+	  if (REG_P (sub) || GET_CODE (sub) == SUBREG)
 	    {
 	      rtx tem;
 
@@ -3385,7 +3385,7 @@ insns_for_mem_walk (rtx *r, void *data)
   tmp.insns = NULL_RTX;
 
   if (ifmwi->pass == 0 && *r && GET_CODE (*r) == ADDRESSOF
-      && GET_CODE (XEXP (*r, 0)) == REG)
+      && REG_P (XEXP (*r, 0)))
     {
       void **e;
       tmp.key = XEXP (*r, 0);
@@ -3396,7 +3396,7 @@ insns_for_mem_walk (rtx *r, void *data)
 	  memcpy (*e, &tmp, sizeof (tmp));
 	}
     }
-  else if (ifmwi->pass == 1 && *r && GET_CODE (*r) == REG)
+  else if (ifmwi->pass == 1 && *r && REG_P (*r))
     {
       struct insns_for_mem_entry *ifme;
       tmp.key = *r;
@@ -3534,7 +3534,7 @@ purge_single_hard_subreg_set (rtx pattern)
   enum machine_mode mode = GET_MODE (SET_DEST (pattern));
   int offset = 0;
 
-  if (GET_CODE (reg) == SUBREG && GET_CODE (SUBREG_REG (reg)) == REG
+  if (GET_CODE (reg) == SUBREG && REG_P (SUBREG_REG (reg))
       && REGNO (SUBREG_REG (reg)) < FIRST_PSEUDO_REGISTER)
     {
       offset = subreg_regno_offset (REGNO (SUBREG_REG (reg)),
@@ -3545,7 +3545,7 @@ purge_single_hard_subreg_set (rtx pattern)
     }
 
 
-  if (GET_CODE (reg) == REG && REGNO (reg) < FIRST_PSEUDO_REGISTER)
+  if (REG_P (reg) && REGNO (reg) < FIRST_PSEUDO_REGISTER)
     {
       reg = gen_rtx_REG (mode, REGNO (reg) + offset);
       SET_DEST (pattern) = reg;
@@ -3724,8 +3724,8 @@ instantiate_decl (rtx x, HOST_WIDE_INT size, int valid_only)
 
   addr = XEXP (x, 0);
   if (CONSTANT_P (addr)
-      || (GET_CODE (addr) == ADDRESSOF && GET_CODE (XEXP (addr, 0)) == REG)
-      || (GET_CODE (addr) == REG
+      || (GET_CODE (addr) == ADDRESSOF && REG_P (XEXP (addr, 0)))
+      || (REG_P (addr)
 	  && (REGNO (addr) < FIRST_VIRTUAL_REGISTER
 	      || REGNO (addr) > LAST_VIRTUAL_REGISTER)))
     return;
@@ -3883,14 +3883,14 @@ instantiate_virtual_regs_1 (rtx *loc, rtx object, int extra_insns)
 
 	  /* The only valid sources here are PLUS or REG.  Just do
 	     the simplest possible thing to handle them.  */
-	  if (GET_CODE (src) != REG && GET_CODE (src) != PLUS)
+	  if (!REG_P (src) && GET_CODE (src) != PLUS)
 	    {
 	      instantiate_virtual_regs_lossage (object);
 	      return 1;
 	    }
 
 	  start_sequence ();
-	  if (GET_CODE (src) != REG)
+	  if (!REG_P (src))
 	    temp = force_operand (src, NULL_RTX);
 	  else
 	    temp = src;
@@ -3956,7 +3956,7 @@ instantiate_virtual_regs_1 (rtx *loc, rtx object, int extra_insns)
 	      /* We know the second operand is a constant.  Unless the
 		 first operand is a REG (which has been already checked),
 		 it needs to be checked.  */
-	      if (GET_CODE (XEXP (x, 0)) != REG)
+	      if (!REG_P (XEXP (x, 0)))
 		{
 		  loc = &XEXP (x, 0);
 		  goto restart;
@@ -4145,7 +4145,7 @@ instantiate_virtual_regs_1 (rtx *loc, rtx object, int extra_insns)
       if ((GET_CODE (XEXP (x, 0)) == MEM
 	   && instantiate_virtual_regs_1 (&XEXP (XEXP (x, 0), 0), XEXP (x, 0),
 					  0))
-	  || (GET_CODE (XEXP (x, 0)) == REG
+	  || (REG_P (XEXP (x, 0))
 	      && instantiate_virtual_regs_1 (&XEXP (x, 0), object, 0)))
 	return 1;
 
@@ -4179,7 +4179,7 @@ instantiate_virtual_regs_1 (rtx *loc, rtx object, int extra_insns)
       return 1;
 
     case ADDRESSOF:
-      if (GET_CODE (XEXP (x, 0)) == REG)
+      if (REG_P (XEXP (x, 0)))
 	return 1;
 
       else if (GET_CODE (XEXP (x, 0)) == MEM)
@@ -4273,7 +4273,7 @@ aggregate_value_p (tree exp, tree fntype)
 
   /* If we have something other than a REG (e.g. a PARALLEL), then assume
      it is OK.  */
-  if (GET_CODE (reg) != REG)
+  if (!REG_P (reg))
     return 0;
 
   regno = REGNO (reg);
@@ -4711,7 +4711,7 @@ assign_parms (tree fndecl)
 
 	  for (i = 0; i < len; i++)
 	    if (XEXP (XVECEXP (entry_parm, 0, i), 0) != NULL_RTX
-		&& GET_CODE (XEXP (XVECEXP (entry_parm, 0, i), 0)) == REG
+		&& REG_P (XEXP (XVECEXP (entry_parm, 0, i), 0))
 		&& (GET_MODE (XEXP (XVECEXP (entry_parm, 0, i), 0))
 		    == passed_mode)
 		&& INTVAL (XEXP (XVECEXP (entry_parm, 0, i), 1)) == 0)
@@ -4781,7 +4781,7 @@ assign_parms (tree fndecl)
 	  /* If a BLKmode arrives in registers, copy it to a stack slot.
 	     Handle calls that pass values in multiple non-contiguous
 	     locations.  The Irix 6 ABI has examples of this.  */
-	  if (GET_CODE (entry_parm) == REG
+	  if (REG_P (entry_parm)
 	      || (GET_CODE (entry_parm) == PARALLEL
 		 && (!loaded_in_reg || !optimize)))
 	    {
@@ -4947,7 +4947,7 @@ assign_parms (tree fndecl)
 
 	      if (GET_CODE (tempreg) == SUBREG
 		  && GET_MODE (tempreg) == nominal_mode
-		  && GET_CODE (SUBREG_REG (tempreg)) == REG
+		  && REG_P (SUBREG_REG (tempreg))
 		  && nominal_mode == passed_mode
 		  && GET_MODE (SUBREG_REG (tempreg)) == GET_MODE (entry_parm)
 		  && GET_MODE_SIZE (GET_MODE (tempreg))
@@ -5433,7 +5433,7 @@ promoted_input_arg (unsigned int regno, enum machine_mode *pmode, int *punsigned
 
   for (arg = DECL_ARGUMENTS (current_function_decl); arg;
        arg = TREE_CHAIN (arg))
-    if (GET_CODE (DECL_INCOMING_RTL (arg)) == REG
+    if (REG_P (DECL_INCOMING_RTL (arg))
 	&& REGNO (DECL_INCOMING_RTL (arg)) == regno
 	&& TYPE_MODE (DECL_ARG_TYPE (arg)) == TYPE_MODE (TREE_TYPE (arg)))
       {
@@ -5708,7 +5708,7 @@ setjmp_vars_warning (tree block)
     {
       if (TREE_CODE (decl) == VAR_DECL
 	  && DECL_RTL_SET_P (decl)
-	  && GET_CODE (DECL_RTL (decl)) == REG
+	  && REG_P (DECL_RTL (decl))
 	  && regno_clobbered_at_setjmp (REGNO (DECL_RTL (decl))))
 	warning ("%Jvariable '%D' might be clobbered by `longjmp' or `vfork'",
 		 decl, decl);
@@ -5728,7 +5728,7 @@ setjmp_args_warning (void)
   for (decl = DECL_ARGUMENTS (current_function_decl);
        decl; decl = TREE_CHAIN (decl))
     if (DECL_RTL (decl) != 0
-	&& GET_CODE (DECL_RTL (decl)) == REG
+	&& REG_P (DECL_RTL (decl))
 	&& regno_clobbered_at_setjmp (REGNO (DECL_RTL (decl))))
       warning ("%Jargument '%D' might be clobbered by `longjmp' or `vfork'",
 	       decl, decl);
@@ -5745,7 +5745,7 @@ setjmp_protect (tree block)
     if ((TREE_CODE (decl) == VAR_DECL
 	 || TREE_CODE (decl) == PARM_DECL)
 	&& DECL_RTL (decl) != 0
-	&& (GET_CODE (DECL_RTL (decl)) == REG
+	&& (REG_P (DECL_RTL (decl))
 	    || (GET_CODE (DECL_RTL (decl)) == MEM
 		&& GET_CODE (XEXP (DECL_RTL (decl), 0)) == ADDRESSOF))
 	/* If this variable came from an inline function, it must be
@@ -5778,7 +5778,7 @@ setjmp_protect_args (void)
     if ((TREE_CODE (decl) == VAR_DECL
 	 || TREE_CODE (decl) == PARM_DECL)
 	&& DECL_RTL (decl) != 0
-	&& (GET_CODE (DECL_RTL (decl)) == REG
+	&& (REG_P (DECL_RTL (decl))
 	    || (GET_CODE (DECL_RTL (decl)) == MEM
 		&& GET_CODE (XEXP (DECL_RTL (decl), 0)) == ADDRESSOF))
 	&& (
@@ -5815,7 +5815,7 @@ fix_lexical_addr (rtx addr, tree var)
     addr = XEXP (XEXP (addr, 0), 0);
 
   /* Decode given address as base reg plus displacement.  */
-  if (GET_CODE (addr) == REG)
+  if (REG_P (addr))
     basereg = addr, displacement = 0;
   else if (GET_CODE (addr) == PLUS && GET_CODE (XEXP (addr, 1)) == CONST_INT)
     basereg = XEXP (addr, 0), displacement = INTVAL (XEXP (addr, 1));
@@ -6592,7 +6592,7 @@ diddle_return_value (void (*doit) (rtx, void *), void *arg)
   if (! outgoing)
     return;
 
-  if (GET_CODE (outgoing) == REG)
+  if (REG_P (outgoing))
     (*doit) (outgoing, arg);
   else if (GET_CODE (outgoing) == PARALLEL)
     {
@@ -6602,7 +6602,7 @@ diddle_return_value (void (*doit) (rtx, void *), void *arg)
 	{
 	  rtx x = XEXP (XVECEXP (outgoing, 0, i), 0);
 
-	  if (GET_CODE (x) == REG && REGNO (x) < FIRST_PSEUDO_REGISTER)
+	  if (REG_P (x) && REGNO (x) < FIRST_PSEUDO_REGISTER)
 	    (*doit) (x, arg);
 	}
     }
@@ -7154,7 +7154,7 @@ keep_stack_depressed (rtx insns)
 	     unchanged.  Otherwise, it must be a MEM and we see what the
 	     base register and offset are.  In any case, we have to emit any
 	     pending load to the equivalent reg of SP, if any.  */
-	  if (GET_CODE (retaddr) == REG)
+	  if (REG_P (retaddr))
 	    {
 	      emit_equiv_load (&info);
 	      add_insn (insn);
@@ -7162,11 +7162,11 @@ keep_stack_depressed (rtx insns)
 	      continue;
 	    }
 	  else if (GET_CODE (retaddr) == MEM
-		   && GET_CODE (XEXP (retaddr, 0)) == REG)
+		   && REG_P (XEXP (retaddr, 0)))
 	    base = gen_rtx_REG (Pmode, REGNO (XEXP (retaddr, 0))), offset = 0;
 	  else if (GET_CODE (retaddr) == MEM
 		   && GET_CODE (XEXP (retaddr, 0)) == PLUS
-		   && GET_CODE (XEXP (XEXP (retaddr, 0), 0)) == REG
+		   && REG_P (XEXP (XEXP (retaddr, 0), 0))
 		   && GET_CODE (XEXP (XEXP (retaddr, 0), 1)) == CONST_INT)
 	    {
 	      base = gen_rtx_REG (Pmode, REGNO (XEXP (XEXP (retaddr, 0), 0)));
@@ -7291,7 +7291,7 @@ handle_epilogue_set (rtx set, struct epi_info *p)
 	  p->new_sp_equiv_reg = XEXP (SET_SRC (set), 0);
 	  if (GET_CODE (XEXP (SET_SRC (set), 1)) == CONST_INT)
 	    p->new_sp_offset = INTVAL (XEXP (SET_SRC (set), 1));
-	  else if (GET_CODE (XEXP (SET_SRC (set), 1)) == REG
+	  else if (REG_P (XEXP (SET_SRC (set), 1))
 		   && REGNO (XEXP (SET_SRC (set), 1)) < FIRST_PSEUDO_REGISTER
 		   && p->const_equiv[REGNO (XEXP (SET_SRC (set), 1))] != 0)
 	    p->new_sp_offset
@@ -7309,7 +7309,7 @@ handle_epilogue_set (rtx set, struct epi_info *p)
 	  p->new_sp_offset += p->sp_offset;
 	}
 
-      if (p->new_sp_equiv_reg == 0 || GET_CODE (p->new_sp_equiv_reg) != REG)
+      if (p->new_sp_equiv_reg == 0 || !REG_P (p->new_sp_equiv_reg))
 	abort ();
 
       return;
@@ -7326,8 +7326,8 @@ handle_epilogue_set (rtx set, struct epi_info *p)
   else if (p->new_sp_equiv_reg != 0 && reg_set_p (p->new_sp_equiv_reg, set))
     {
       if (p->equiv_reg_src != 0
-	  || GET_CODE (p->new_sp_equiv_reg) != REG
-	  || GET_CODE (SET_DEST (set)) != REG
+	  || !REG_P (p->new_sp_equiv_reg)
+	  || !REG_P (SET_DEST (set))
 	  || GET_MODE_BITSIZE (GET_MODE (SET_DEST (set))) > BITS_PER_WORD
 	  || REGNO (p->new_sp_equiv_reg) != REGNO (SET_DEST (set)))
 	abort ();
@@ -7360,7 +7360,7 @@ update_epilogue_consts (rtx dest, rtx x, void *data)
   struct epi_info *p = (struct epi_info *) data;
   rtx new;
 
-  if (GET_CODE (dest) != REG || REGNO (dest) >= FIRST_PSEUDO_REGISTER)
+  if (!REG_P (dest) || REGNO (dest) >= FIRST_PSEUDO_REGISTER)
     return;
 
   /* If we are either clobbering a register or doing a partial set,
@@ -7375,7 +7375,7 @@ update_epilogue_consts (rtx dest, rtx x, void *data)
   /* If this is a binary operation between a register we have been tracking
      and a constant, see if we can compute a new constant value.  */
   else if (ARITHMETIC_P (SET_SRC (x))
-	   && GET_CODE (XEXP (SET_SRC (x), 0)) == REG
+	   && REG_P (XEXP (SET_SRC (x), 0))
 	   && REGNO (XEXP (SET_SRC (x), 0)) < FIRST_PSEUDO_REGISTER
 	   && p->const_equiv[REGNO (XEXP (SET_SRC (x), 0))] != 0
 	   && GET_CODE (XEXP (SET_SRC (x), 1)) == CONST_INT