Use std::swap instead of explicit swaps

gcc/
	* bb-reorder.c (fix_up_fall_thru_edges): Use std::swap instead of
	explicit swaps.
	* dojump.c (do_compare_rtx_and_jump): Likewise.
	* expmed.c (emit_store_flag_1): Likewise.
	* fibonacci_heap.h (fibonacci_heap::union_with): Likewise.
	* final.c (sprint_ul): Use std::reverse for reversing a string.
	* fold-const.c (extract_muldiv_1): Use std::swap.
	* genmodes.c (emit_mode_int_n): Likewise.
	* ifcvt.c (dead_or_predicable): Likewise.
	* ira-build.c (ira_merge_live_ranges): Likewise.
	(swap_allocno_copy_ends_if_necessary): Likewise.
	* ira.c (ira_setup_alts): Likewise.
	* loop-iv.c (iv_analyze_expr): Likewise.
	(implies_p): Likewise.
	(canon_condition): Likewise.
	* lra-constraints.c (swap_operands): Likewise.
	* lra-lives.c (lra_merge_live_ranges): Likewise.
	* omega.c (swap): Remove.
	(bswap): Remove.
	(omega_unprotect_1): Use std::swap.
	(omega_solve_geq): Likewise.
	* optabs.c (expand_binop_directly): Likewise.
	(expand_binop): Likewise.
	(emit_conditional_move): Likewise.
	(emit_conditional_add): Likewise.
	* postreload.c (reload_cse_simplify_operands): Likewise.
	* reg-stack.c (emit_swap_insn): Likewise.
	(swap_to_top): Likewise.
	(compare_for_stack_reg): Likewise.
	(subst_asm_stack_regs): Likewise.
	* reload.c (find_reloads): Likewise.
	* reload1.c (gen_reload_chain_without_interm_reg_p): Likewise.
	* sel-sched.c (invoke_reorder_hooks): Likewise.
	(create_block_for_bookkeeping): Likewise.
	* tree-data-ref.c (lambda_matrix_row_exchange): Remove.
	(lambda_matrix_right_hermite): Use std::swap.
	* tree-ssa-coalesce.c (sort_coalesce_list): Likewise.
	* tree-ssa-ifcombine.c (ifcombine_ifandif): Likewise.
	* tree-ssa-loop-ivopts.c (iv_ca_delta_reverse): Likewise.
	* tree-ssa-math-opts.c (is_widening_mult_p): Likewise.
	* tree-ssa-phiopt.c (hoist_adjacent_loads): Likewise.
	* tree-ssa-reassoc.c (linearize_expr_tree): Likewise.
	* tree-ssa-threadedge.c (simplify_control_stmt_condition): Likewise.
	* tree-vrp.c (compare_ranges): Likewise.
	* var-tracking.c (add_with_sets): Likewise.
	(vt_find_locations): Likewise.

gcc/c/
	* c-typeck.c (build_array_ref): Use std::swap instead of explicit
	swaps

gcc/cp/
	* typeck.c (composite_pointer_type): Use std::swap instead of explicit
	swaps.

gcc/c-family/
	* c-common.c (shorten_compare): Use std::swap instead of explicit swaps.

gcc/fortran/
	* interface.c (compare_actual_formal): Use std::swap instead of
	explicit swaps.
	* trans-array.c (gfc_trans_scalarized_loop_end): Likewise.
	* trans-intrinsic.c (walk_inline_intrinsic_transpose): Likewise.

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

41 files changed, 207 insertions, 423 deletions

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index c00a8789d45..44017c18067 100644
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,52 @@
+2015-05-19  Mikhail Maltsev  <maltsevm@gmail.com>
+
+	* bb-reorder.c (fix_up_fall_thru_edges): Use std::swap instead of
+	explicit swaps.
+	* dojump.c (do_compare_rtx_and_jump): Likewise.
+	* expmed.c (emit_store_flag_1): Likewise.
+	* fibonacci_heap.h (fibonacci_heap::union_with): Likewise.
+	* final.c (sprint_ul): Use std::reverse for reversing a string.
+	* fold-const.c (extract_muldiv_1): Use std::swap.
+	* genmodes.c (emit_mode_int_n): Likewise.
+	* ifcvt.c (dead_or_predicable): Likewise.
+	* ira-build.c (ira_merge_live_ranges): Likewise.
+	(swap_allocno_copy_ends_if_necessary): Likewise.
+	* ira.c (ira_setup_alts): Likewise.
+	* loop-iv.c (iv_analyze_expr): Likewise.
+	(implies_p): Likewise.
+	(canon_condition): Likewise.
+	* lra-constraints.c (swap_operands): Likewise.
+	* lra-lives.c (lra_merge_live_ranges): Likewise.
+	* omega.c (swap): Remove.
+	(bswap): Remove.
+	(omega_unprotect_1): Use std::swap.
+	(omega_solve_geq): Likewise.
+	* optabs.c (expand_binop_directly): Likewise.
+	(expand_binop): Likewise.
+	(emit_conditional_move): Likewise.
+	(emit_conditional_add): Likewise.
+	* postreload.c (reload_cse_simplify_operands): Likewise.
+	* reg-stack.c (emit_swap_insn): Likewise.
+	(swap_to_top): Likewise.
+	(compare_for_stack_reg): Likewise.
+	(subst_asm_stack_regs): Likewise.
+	* reload.c (find_reloads): Likewise.
+	* reload1.c (gen_reload_chain_without_interm_reg_p): Likewise.
+	* sel-sched.c (invoke_reorder_hooks): Likewise.
+	(create_block_for_bookkeeping): Likewise.
+	* tree-data-ref.c (lambda_matrix_row_exchange): Remove.
+	(lambda_matrix_right_hermite): Use std::swap.
+	* tree-ssa-coalesce.c (sort_coalesce_list): Likewise.
+	* tree-ssa-ifcombine.c (ifcombine_ifandif): Likewise.
+	* tree-ssa-loop-ivopts.c (iv_ca_delta_reverse): Likewise.
+	* tree-ssa-math-opts.c (is_widening_mult_p): Likewise.
+	* tree-ssa-phiopt.c (hoist_adjacent_loads): Likewise.
+	* tree-ssa-reassoc.c (linearize_expr_tree): Likewise.
+	* tree-ssa-threadedge.c (simplify_control_stmt_condition): Likewise.
+	* tree-vrp.c (compare_ranges): Likewise.
+	* var-tracking.c (add_with_sets): Likewise.
+	(vt_find_locations): Likewise.
+
 2015-05-18  Andreas Tobler  <andreast@gcc.gnu.org>
 
 	* config/freebsd-spec.h (FBSD_STARTFILE_SPEC): Add the bits to build
diff --git a/gcc/bb-reorder.c b/gcc/bb-reorder.c
index c1347121f51..a97c2cd4c97 100644
--- a/gcc/bb-reorder.c
+++ b/gcc/bb-reorder.c
@@ -1812,7 +1812,6 @@ fix_up_fall_thru_edges (void)
   edge succ2;
   edge fall_thru;
   edge cond_jump = NULL;
-  edge e;
   bool cond_jump_crosses;
   int invert_worked;
   rtx_insn *old_jump;
@@ -1901,9 +1900,7 @@ fix_up_fall_thru_edges (void)
 			  fall_thru->flags &= ~EDGE_FALLTHRU;
 			  cond_jump->flags |= EDGE_FALLTHRU;
 			  update_br_prob_note (cur_bb);
-			  e = fall_thru;
-			  fall_thru = cond_jump;
-			  cond_jump = e;
+			  std::swap (fall_thru, cond_jump);
 			  cond_jump->flags |= EDGE_CROSSING;
 			  fall_thru->flags &= ~EDGE_CROSSING;
 			}
diff --git a/gcc/c-family/ChangeLog b/gcc/c-family/ChangeLog
index a6abd601b08..bf403ce57c7 100644
--- a/gcc/c-family/ChangeLog
+++ b/gcc/c-family/ChangeLog
@@ -1,3 +1,7 @@
+2015-05-19  Mikhail Maltsev  <maltsevm@gmail.com>
+
+	* c-common.c (shorten_compare): Use std::swap instead of explicit swaps.
+
 2015-05-18  Tom de Vries  <tom@codesourcery.com>
 
 	* c-common.c (build_va_arg_1): New function.
diff --git a/gcc/c-family/c-common.c b/gcc/c-family/c-common.c
index 6d8504905d1..3998b23b00b 100644
--- a/gcc/c-family/c-common.c
+++ b/gcc/c-family/c-common.c
@@ -4372,20 +4372,12 @@ shorten_compare (location_t loc, tree *op0_ptr, tree *op1_ptr,
       && !integer_zerop (primop1) && !real_zerop (primop1)
       && !fixed_zerop (primop1))
     {
-      tree tem = primop0;
-      int temi = unsignedp0;
-      primop0 = primop1;
-      primop1 = tem;
-      tem = op0;
-      op0 = op1;
-      op1 = tem;
+      std::swap (primop0, primop1);
+      std::swap (op0, op1);
       *op0_ptr = op0;
       *op1_ptr = op1;
-      unsignedp0 = unsignedp1;
-      unsignedp1 = temi;
-      temi = real1;
-      real1 = real2;
-      real2 = temi;
+      std::swap (unsignedp0, unsignedp1);
+      std::swap (real1, real2);
 
       switch (code)
 	{
diff --git a/gcc/c/ChangeLog b/gcc/c/ChangeLog
index 6ef290f7933..d573d7ab6d4 100644
--- a/gcc/c/ChangeLog
+++ b/gcc/c/ChangeLog
@@ -1,3 +1,8 @@
+2015-05-19  Mikhail Maltsev  <maltsevm@gmail.com>
+
+	* c-typeck.c (build_array_ref): Use std::swap instead of explicit
+	swaps
+
 2015-05-16  Manuel López-Ibáñez  <manu@gcc.gnu.org>
 
 	PR fortran/44054
diff --git a/gcc/c/c-typeck.c b/gcc/c/c-typeck.c
index 9b883a22f2b..7f544902bb1 100644
--- a/gcc/c/c-typeck.c
+++ b/gcc/c/c-typeck.c
@@ -2474,7 +2474,6 @@ build_array_ref (location_t loc, tree array, tree index)
       /* Allow vector[index] but not index[vector].  */
       && TREE_CODE (TREE_TYPE (array)) != VECTOR_TYPE)
     {
-      tree temp;
       if (TREE_CODE (TREE_TYPE (index)) != ARRAY_TYPE
 	  && TREE_CODE (TREE_TYPE (index)) != POINTER_TYPE)
 	{
@@ -2483,9 +2482,7 @@ build_array_ref (location_t loc, tree array, tree index)
 
 	  return error_mark_node;
 	}
-      temp = array;
-      array = index;
-      index = temp;
+      std::swap (array, index);
       swapped = true;
     }
 
diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog
index b21e6a07974..3271a5491f6 100644
--- a/gcc/cp/ChangeLog
+++ b/gcc/cp/ChangeLog
@@ -1,3 +1,8 @@
+2015-05-19  Mikhail Maltsev  <maltsevm@gmail.com>
+
+	* typeck.c (composite_pointer_type): Use std::swap instead of explicit
+	swaps.
+
 2015-05-18  Jason Merrill  <jason@redhat.com>
 
 	* pt.c (retrieve_specialization): Make sure our arguments have
diff --git a/gcc/cp/typeck.c b/gcc/cp/typeck.c
index 549e4b161f5..a4d702b2a1d 100644
--- a/gcc/cp/typeck.c
+++ b/gcc/cp/typeck.c
@@ -606,12 +606,7 @@ composite_pointer_type (tree t1, tree t2, tree arg1, tree arg2,
 
     If either type is a pointer to void, make sure it is T1.  */
   if (TYPE_PTR_P (t2) && VOID_TYPE_P (TREE_TYPE (t2)))
-    {
-      tree t;
-      t = t1;
-      t1 = t2;
-      t2 = t;
-    }
+    std::swap (t1, t2);
 
   /* Now, if T1 is a pointer to void, merge the qualifiers.  */
   if (TYPE_PTR_P (t1) && VOID_TYPE_P (TREE_TYPE (t1)))
diff --git a/gcc/dojump.c b/gcc/dojump.c
index 0790c77d239..b564d6417bf 100644
--- a/gcc/dojump.c
+++ b/gcc/dojump.c
@@ -1096,11 +1096,8 @@ do_compare_rtx_and_jump (rtx op0, rtx op1, enum rtx_code code, int unsignedp,
 	  && ! can_compare_p (code, mode, ccp_jump)
 	  && can_compare_p (swap_condition (code), mode, ccp_jump))
 	{
-	  rtx tmp;
 	  code = swap_condition (code);
-	  tmp = op0;
-	  op0 = op1;
-	  op1 = tmp;
+	  std::swap (op0, op1);
 	}
       else if (SCALAR_FLOAT_MODE_P (mode)
 	       && ! can_compare_p (code, mode, ccp_jump)
diff --git a/gcc/expmed.c b/gcc/expmed.c
index 6679f501c2c..2da9a6552a0 100644
--- a/gcc/expmed.c
+++ b/gcc/expmed.c
@@ -5256,7 +5256,6 @@ emit_store_flag_1 (rtx target, enum rtx_code code, rtx op0, rtx op1,
   machine_mode compare_mode;
   enum mode_class mclass;
   enum rtx_code scode;
-  rtx tem;
 
   if (unsignedp)
     code = unsigned_condition (code);
@@ -5267,9 +5266,7 @@ emit_store_flag_1 (rtx target, enum rtx_code code, rtx op0, rtx op1,
 
   if (swap_commutative_operands_p (op0, op1))
     {
-      tem = op0;
-      op0 = op1;
-      op1 = tem;
+      std::swap (op0, op1);
       code = swap_condition (code);
     }
 
@@ -5316,6 +5313,7 @@ emit_store_flag_1 (rtx target, enum rtx_code code, rtx op0, rtx op1,
       && GET_MODE_CLASS (mode) == MODE_INT
       && (!MEM_P (op0) || ! MEM_VOLATILE_P (op0)))
     {
+      rtx tem;
       if ((code == EQ || code == NE)
 	  && (op1 == const0_rtx || op1 == constm1_rtx))
 	{
@@ -5415,8 +5413,8 @@ emit_store_flag_1 (rtx target, enum rtx_code code, rtx op0, rtx op1,
      if (icode != CODE_FOR_nothing)
 	{
 	  do_pending_stack_adjust ();
-	  tem = emit_cstore (target, icode, code, mode, compare_mode,
-			     unsignedp, op0, op1, normalizep, target_mode);
+	  rtx tem = emit_cstore (target, icode, code, mode, compare_mode,
+				 unsignedp, op0, op1, normalizep, target_mode);
 	  if (tem)
 	    return tem;
 
diff --git a/gcc/fibonacci_heap.h b/gcc/fibonacci_heap.h
index 0d9226bbca9..2e74176f58a 100644
--- a/gcc/fibonacci_heap.h
+++ b/gcc/fibonacci_heap.h
@@ -457,7 +457,7 @@ fibonacci_heap<K,V>::union_with (fibonacci_heap<K,V> *heapb)
 {
   fibonacci_heap<K,V> *heapa = this;
 
-  fibonacci_node<K,V> *a_root, *b_root, *temp;
+  fibonacci_node<K,V> *a_root, *b_root;
 
   /* If one of the heaps is empty, the union is just the other heap.  */
   if ((a_root = heapa->m_root) == NULL)
@@ -474,9 +474,7 @@ fibonacci_heap<K,V>::union_with (fibonacci_heap<K,V> *heapb)
   /* Merge them to the next nodes on the opposite chain.  */
   a_root->m_left->m_right = b_root;
   b_root->m_left->m_right = a_root;
-  temp = a_root->m_left;
-  a_root->m_left = b_root->m_left;
-  b_root->m_left = temp;
+  std::swap (a_root->m_left, b_root->m_left);
   heapa->m_nodes += heapb->m_nodes;
 
   /* And set the new minimum, if it's changed.  */
diff --git a/gcc/final.c b/gcc/final.c
index 0c91095bae4..aaeececc0b4 100644
--- a/gcc/final.c
+++ b/gcc/final.c
@@ -4131,25 +4131,10 @@ fprint_ul (FILE *f, unsigned long value)
 int
 sprint_ul (char *s, unsigned long value)
 {
-  int len;
-  char tmp_c;
-  int i;
-  int j;
-
-  len = sprint_ul_rev (s, value);
+  int len = sprint_ul_rev (s, value);
   s[len] = '\0';
 
-  /* Reverse the string. */
-  i = 0;
-  j = len - 1;
-  while (i < j)
-    {
-      tmp_c = s[i];
-      s[i] = s[j];
-      s[j] = tmp_c;
-      i++; j--;
-    }
-
+  std::reverse (s, s + len);
   return len;
 }
 
diff --git a/gcc/fold-const.c b/gcc/fold-const.c
index 3654fd670b0..1476ee0b1ed 100644
--- a/gcc/fold-const.c
+++ b/gcc/fold-const.c
@@ -6139,12 +6139,8 @@ extract_muldiv_1 (tree t, tree c, enum tree_code code, tree wide_type,
 	  /* If OP1 was not easily negatable, the constant may be OP0.  */
 	  if (TREE_CODE (op0) == INTEGER_CST)
 	    {
-	      tree tem = op0;
-	      op0 = op1;
-	      op1 = tem;
-	      tem = t1;
-	      t1 = t2;
-	      t2 = tem;
+	      std::swap (op0, op1);
+	      std::swap (t1, t2);
 	    }
 	}
 
diff --git a/gcc/fortran/ChangeLog b/gcc/fortran/ChangeLog
index de7be7aa65d..6b3ad092987 100644
--- a/gcc/fortran/ChangeLog
+++ b/gcc/fortran/ChangeLog
@@ -1,3 +1,10 @@
+2015-05-19  Mikhail Maltsev  <maltsevm@gmail.com>
+
+	* interface.c (compare_actual_formal): Use std::swap instead of
+	explicit swaps.
+	* trans-array.c (gfc_trans_scalarized_loop_end): Likewise.
+	* trans-intrinsic.c (walk_inline_intrinsic_transpose): Likewise.
+
 2015-05-18  Steven G. Kargl  <kargl@gcc.gnu.org>
 
 	PR fortran/66106
diff --git a/gcc/fortran/interface.c b/gcc/fortran/interface.c
index d011d846d31..9f55f0a19f9 100644
--- a/gcc/fortran/interface.c
+++ b/gcc/fortran/interface.c
@@ -2566,7 +2566,7 @@ static int
 compare_actual_formal (gfc_actual_arglist **ap, gfc_formal_arglist *formal,
 	 	       int ranks_must_agree, int is_elemental, locus *where)
 {
-  gfc_actual_arglist **new_arg, *a, *actual, temp;
+  gfc_actual_arglist **new_arg, *a, *actual;
   gfc_formal_arglist *f;
   int i, n, na;
   unsigned long actual_size, formal_size;
@@ -3029,13 +3029,8 @@ compare_actual_formal (gfc_actual_arglist **ap, gfc_formal_arglist *formal,
 
   if (na != 0)
     {
-      temp = *new_arg[0];
-      *new_arg[0] = *actual;
-      *actual = temp;
-
-      a = new_arg[0];
-      new_arg[0] = new_arg[na];
-      new_arg[na] = a;
+      std::swap (*new_arg[0], *actual);
+      std::swap (new_arg[0], new_arg[na]);
     }
 
   for (i = 0; i < n - 1; i++)
diff --git a/gcc/fortran/trans-array.c b/gcc/fortran/trans-array.c
index 8267f6a41f9..e6edf742377 100644
--- a/gcc/fortran/trans-array.c
+++ b/gcc/fortran/trans-array.c
@@ -3644,11 +3644,7 @@ gfc_trans_scalarized_loop_end (gfc_loopinfo * loop, int n,
       loopbody = gfc_finish_block (pbody);
 
       if (reverse_loop)
-	{
-	  tmp = loop->from[n];
-	  loop->from[n] = loop->to[n];
-	  loop->to[n] = tmp;
-	}
+	std::swap (loop->from[n], loop->to[n]);
 
       /* Initialize the loopvar.  */
       if (loop->loopvar[n] != loop->from[n])
diff --git a/gcc/fortran/trans-intrinsic.c b/gcc/fortran/trans-intrinsic.c
index 20e5b37e240..323c600c99c 100644
--- a/gcc/fortran/trans-intrinsic.c
+++ b/gcc/fortran/trans-intrinsic.c
@@ -8324,14 +8324,10 @@ walk_inline_intrinsic_transpose (gfc_ss *ss, gfc_expr *expr)
       if (tmp_ss->info->type != GFC_SS_SCALAR
 	  && tmp_ss->info->type != GFC_SS_REFERENCE)
 	{
-	  int tmp_dim;
-
 	  gcc_assert (tmp_ss->dimen == 2);
 
 	  /* We just invert dimensions.  */
-	  tmp_dim = tmp_ss->dim[0];
-	  tmp_ss->dim[0] = tmp_ss->dim[1];
-	  tmp_ss->dim[1] = tmp_dim;
+	  std::swap (tmp_ss->dim[0], tmp_ss->dim[1]);
 	}
 
       /* Stop when tmp_ss points to the last valid element of the chain...  */
diff --git a/gcc/genmodes.c b/gcc/genmodes.c
index 45681f5db3f..af1fe4f6c93 100644
--- a/gcc/genmodes.c
+++ b/gcc/genmodes.c
@@ -1600,11 +1600,7 @@ emit_mode_int_n (void)
   for (i = 0; i<n_modes - 1; i++)
     for (j = i + 1; j < n_modes; j++)
       if (mode_sort[i]->int_n > mode_sort[j]->int_n)
-	{
-	  m = mode_sort[i];
-	  mode_sort[i] = mode_sort[j];
-	  mode_sort[j] = m;
-	}
+	std::swap (mode_sort[i], mode_sort[j]);
 
   for (i = 0; i < n_modes; i ++)
     {
diff --git a/gcc/ifcvt.c b/gcc/ifcvt.c
index fc7c4f1f518..afeb034fc06 100644
--- a/gcc/ifcvt.c
+++ b/gcc/ifcvt.c
@@ -4462,14 +4462,10 @@ dead_or_predicable (basic_block test_bb, basic_block merge_bb,
       redirect_edge_succ (BRANCH_EDGE (test_bb), new_dest);
       if (reversep)
 	{
-	  gcov_type count, probability;
-	  count = BRANCH_EDGE (test_bb)->count;
-	  BRANCH_EDGE (test_bb)->count = FALLTHRU_EDGE (test_bb)->count;
-	  FALLTHRU_EDGE (test_bb)->count = count;
-	  probability = BRANCH_EDGE (test_bb)->probability;
-	  BRANCH_EDGE (test_bb)->probability
-	    = FALLTHRU_EDGE (test_bb)->probability;
-	  FALLTHRU_EDGE (test_bb)->probability = probability;
+	  std::swap (BRANCH_EDGE (test_bb)->count,
+		     FALLTHRU_EDGE (test_bb)->count);
+	  std::swap (BRANCH_EDGE (test_bb)->probability,
+		     FALLTHRU_EDGE (test_bb)->probability);
 	  update_br_prob_note (test_bb);
 	}
     }
diff --git a/gcc/ira-build.c b/gcc/ira-build.c
index 189f340800a..8b6b9564fcb 100644
--- a/gcc/ira-build.c
+++ b/gcc/ira-build.c
@@ -1000,7 +1000,7 @@ ira_copy_live_range_list (live_range_t r)
 live_range_t
 ira_merge_live_ranges (live_range_t r1, live_range_t r2)
 {
-  live_range_t first, last, temp;
+  live_range_t first, last;
 
   if (r1 == NULL)
     return r2;
@@ -1009,18 +1009,14 @@ ira_merge_live_ranges (live_range_t r1, live_range_t r2)
   for (first = last = NULL; r1 != NULL && r2 != NULL;)
     {
       if (r1->start < r2->start)
-	{
-	  temp = r1;
-	  r1 = r2;
-	  r2 = temp;
-	}
+	std::swap (r1, r2);
       if (r1->start <= r2->finish + 1)
 	{
 	  /* Intersected ranges: merge r1 and r2 into r1.  */
 	  r1->start = r2->start;
 	  if (r1->finish < r2->finish)
 	    r1->finish = r2->finish;
-	  temp = r2;
+	  live_range_t temp = r2;
 	  r2 = r2->next;
 	  ira_finish_live_range (temp);
 	  if (r2 == NULL)
@@ -1479,23 +1475,12 @@ add_allocno_copy_to_list (ira_copy_t cp)
 static void
 swap_allocno_copy_ends_if_necessary (ira_copy_t cp)
 {
-  ira_allocno_t temp;
-  ira_copy_t temp_cp;
-
   if (ALLOCNO_NUM (cp->first) <= ALLOCNO_NUM (cp->second))
     return;
 
-  temp = cp->first;
-  cp->first = cp->second;
-  cp->second = temp;
-
-  temp_cp = cp->prev_first_allocno_copy;
-  cp->prev_first_allocno_copy = cp->prev_second_allocno_copy;
-  cp->prev_second_allocno_copy = temp_cp;
-
-  temp_cp = cp->next_first_allocno_copy;
-  cp->next_first_allocno_copy = cp->next_second_allocno_copy;
-  cp->next_second_allocno_copy = temp_cp;
+  std::swap (cp->first, cp->second);
+  std::swap (cp->prev_first_allocno_copy, cp->prev_second_allocno_copy);
+  std::swap (cp->next_first_allocno_copy, cp->next_second_allocno_copy);
 }
 
 /* Create (or update frequency if the copy already exists) and return
diff --git a/gcc/ira.c b/gcc/ira.c
index 07d6c6951f2..a4108872c28 100644
--- a/gcc/ira.c
+++ b/gcc/ira.c
@@ -1808,7 +1808,6 @@ ira_setup_alts (rtx_insn *insn, HARD_REG_SET &alts)
   int nop, nalt;
   bool curr_swapped;
   const char *p;
-  rtx op;
   int commutative = -1;
 
   extract_insn (insn);
@@ -1850,7 +1849,7 @@ ira_setup_alts (rtx_insn *insn, HARD_REG_SET &alts)
 	    {
 	      int c, len;
 
-	      op = recog_data.operand[nop];
+	      rtx op = recog_data.operand[nop];
 	      p = insn_constraints[nop * recog_data.n_alternatives + nalt];
 	      if (*p == 0 || *p == ',')
 		continue;
@@ -1923,10 +1922,8 @@ ira_setup_alts (rtx_insn *insn, HARD_REG_SET &alts)
 	break;
       if (curr_swapped)
 	break;
-      op = recog_data.operand[commutative];
-      recog_data.operand[commutative] = recog_data.operand[commutative + 1];
-      recog_data.operand[commutative + 1] = op;
-
+      std::swap (recog_data.operand[commutative],
+		 recog_data.operand[commutative + 1]);
     }
 }
 
diff --git a/gcc/loop-iv.c b/gcc/loop-iv.c
index bf6359da4a0..8c3ef7784e6 100644
--- a/gcc/loop-iv.c
+++ b/gcc/loop-iv.c
@@ -977,7 +977,7 @@ bool
 iv_analyze_expr (rtx_insn *insn, rtx rhs, machine_mode mode,
 		 struct rtx_iv *iv)
 {
-  rtx mby = NULL_RTX, tmp;
+  rtx mby = NULL_RTX;
   rtx op0 = NULL_RTX, op1 = NULL_RTX;
   struct rtx_iv iv0, iv1;
   enum rtx_code code = GET_CODE (rhs);
@@ -1028,11 +1028,7 @@ iv_analyze_expr (rtx_insn *insn, rtx rhs, machine_mode mode,
       op0 = XEXP (rhs, 0);
       mby = XEXP (rhs, 1);
       if (!CONSTANT_P (mby))
-	{
-	  tmp = op0;
-	  op0 = mby;
-	  mby = tmp;
-	}
+	std::swap (op0, mby);
       if (!CONSTANT_P (mby))
 	return false;
       break;
@@ -1544,7 +1540,7 @@ replace_in_expr (rtx *expr, rtx dest, rtx src)
 static bool
 implies_p (rtx a, rtx b)
 {
-  rtx op0, op1, opb0, opb1, r;
+  rtx op0, op1, opb0, opb1;
   machine_mode mode;
 
   if (rtx_equal_p (a, b))
@@ -1559,7 +1555,7 @@ implies_p (rtx a, rtx b)
 	  || (GET_CODE (op0) == SUBREG
 	      && REG_P (SUBREG_REG (op0))))
 	{
-	  r = simplify_replace_rtx (b, op0, op1);
+	  rtx r = simplify_replace_rtx (b, op0, op1);
 	  if (r == const_true_rtx)
 	    return true;
 	}
@@ -1568,7 +1564,7 @@ implies_p (rtx a, rtx b)
 	  || (GET_CODE (op1) == SUBREG
 	      && REG_P (SUBREG_REG (op1))))
 	{
-	  r = simplify_replace_rtx (b, op1, op0);
+	  rtx r = simplify_replace_rtx (b, op1, op0);
 	  if (r == const_true_rtx)
 	    return true;
 	}
@@ -1604,18 +1600,10 @@ implies_p (rtx a, rtx b)
     {
 
       if (GET_CODE (a) == GT)
-	{
-	  r = op0;
-	  op0 = op1;
-	  op1 = r;
-	}
+	std::swap (op0, op1);
 
       if (GET_CODE (b) == GE)
-	{
-	  r = opb0;
-	  opb0 = opb1;
-	  opb1 = r;
-	}
+	std::swap (opb0, opb1);
 
       if (SCALAR_INT_MODE_P (mode)
 	  && rtx_equal_p (op1, opb1)
@@ -1707,7 +1695,6 @@ implies_p (rtx a, rtx b)
 rtx
 canon_condition (rtx cond)
 {
-  rtx tem;
   rtx op0, op1;
   enum rtx_code code;
   machine_mode mode;
@@ -1719,9 +1706,7 @@ canon_condition (rtx cond)
   if (swap_commutative_operands_p (op0, op1))
     {
       code = swap_condition (code);
-      tem = op0;
-      op0 = op1;
-      op1 = tem;
+      std::swap (op0, op1);
     }
 
   mode = GET_MODE (op0);
diff --git a/gcc/lra-constraints.c b/gcc/lra-constraints.c
index c8de418144e..b8e9d1f0c16 100644
--- a/gcc/lra-constraints.c
+++ b/gcc/lra-constraints.c
@@ -3293,15 +3293,9 @@ simple_move_p (void)
 static inline void
 swap_operands (int nop)
 {
-  machine_mode mode = curr_operand_mode[nop];
-  curr_operand_mode[nop] = curr_operand_mode[nop + 1];
-  curr_operand_mode[nop + 1] = mode;
-  mode = original_subreg_reg_mode[nop];
-  original_subreg_reg_mode[nop] = original_subreg_reg_mode[nop + 1];
-  original_subreg_reg_mode[nop + 1] = mode;
-  rtx x = *curr_id->operand_loc[nop];
-  *curr_id->operand_loc[nop] = *curr_id->operand_loc[nop + 1];
-  *curr_id->operand_loc[nop + 1] = x;
+  std::swap (curr_operand_mode[nop], curr_operand_mode[nop + 1]);
+  std::swap (original_subreg_reg_mode[nop], original_subreg_reg_mode[nop + 1]);
+  std::swap (*curr_id->operand_loc[nop], *curr_id->operand_loc[nop + 1]);
   /* Swap the duplicates too.  */
   lra_update_dup (curr_id, nop);
   lra_update_dup (curr_id, nop + 1);
diff --git a/gcc/lra-lives.c b/gcc/lra-lives.c
index 47a9ba22b5a..085411ee7d0 100644
--- a/gcc/lra-lives.c
+++ b/gcc/lra-lives.c
@@ -192,7 +192,7 @@ lra_copy_live_range_list (lra_live_range_t r)
 lra_live_range_t
 lra_merge_live_ranges (lra_live_range_t r1, lra_live_range_t r2)
 {
-  lra_live_range_t first, last, temp;
+  lra_live_range_t first, last;
 
   if (r1 == NULL)
     return r2;
@@ -201,16 +201,13 @@ lra_merge_live_ranges (lra_live_range_t r1, lra_live_range_t r2)
   for (first = last = NULL; r1 != NULL && r2 != NULL;)
     {
       if (r1->start < r2->start)
-	{
-	  temp = r1;
-	  r1 = r2;
-	  r2 = temp;
-	}
+	std::swap (r1, r2);
+
       if (r1->start == r2->finish + 1)
 	{
 	  /* Joint ranges: merge r1 and r2 into r1.  */
 	  r1->start = r2->start;
-	  temp = r2;
+	  lra_live_range_t temp = r2;
 	  r2 = r2->next;
 	  pool_free (live_range_pool, temp);
 	}
diff --git a/gcc/omega.c b/gcc/omega.c
index 321fa61d0d2..436d9f7178b 100644
--- a/gcc/omega.c
+++ b/gcc/omega.c
@@ -1882,28 +1882,6 @@ cleanout_wildcards (omega_pb pb)
     normalize_omega_problem (pb);
 }
 
-/* Swap values contained in I and J.  */
-
-static inline void
-swap (int *i, int *j)
-{
-  int tmp;
-  tmp = *i;
-  *i = *j;
-  *j = tmp;
-}
-
-/* Swap values contained in I and J.  */
-
-static inline void
-bswap (bool *i, bool *j)
-{
-  bool tmp;
-  tmp = *i;
-  *i = *j;
-  *j = tmp;
-}
-
 /* Make variable IDX unprotected in PB, by swapping its index at the
    PB->safe_vars rank.  */
 
@@ -1920,19 +1898,19 @@ omega_unprotect_1 (omega_pb pb, int *idx, bool *unprotect)
       for (e = pb->num_geqs - 1; e >= 0; e--)
 	{
 	  pb->geqs[e].touched = 1;
-	  swap (&pb->geqs[e].coef[*idx], &pb->geqs[e].coef[j]);
+	  std::swap (pb->geqs[e].coef[*idx], pb->geqs[e].coef[j]);
 	}
 
       for (e = pb->num_eqs - 1; e >= 0; e--)
-	swap (&pb->eqs[e].coef[*idx], &pb->eqs[e].coef[j]);
+	std::swap (pb->eqs[e].coef[*idx], pb->eqs[e].coef[j]);
 
       for (e = pb->num_subs - 1; e >= 0; e--)
-	swap (&pb->subs[e].coef[*idx], &pb->subs[e].coef[j]);
+	std::swap (pb->subs[e].coef[*idx], pb->subs[e].coef[j]);
 
       if (unprotect)
-	bswap (&unprotect[*idx], &unprotect[j]);
+	std::swap (unprotect[*idx], unprotect[j]);
 
-      swap (&pb->var[*idx], &pb->var[j]);
+      std::swap (pb->var[*idx], pb->var[j]);
       pb->forwarding_address[pb->var[*idx]] = *idx;
       pb->forwarding_address[pb->var[j]] = j;
       (*idx)--;
@@ -3999,7 +3977,6 @@ omega_solve_geq (omega_pb pb, enum omega_result desired_res)
 
       if (i != n_vars)
 	{
-	  int t;
 	  int j = pb->num_vars;
 
 	  if (dump_file && (dump_flags & TDF_DETAILS))
@@ -4008,24 +3985,18 @@ omega_solve_geq (omega_pb pb, enum omega_result desired_res)
 	      omega_print_problem (dump_file, pb);
 	    }
 
-	  swap (&pb->var[i], &pb->var[j]);
+	  std::swap (pb->var[i], pb->var[j]);
 
 	  for (e = pb->num_geqs - 1; e >= 0; e--)
 	    if (pb->geqs[e].coef[i] != pb->geqs[e].coef[j])
 	      {
 		pb->geqs[e].touched = 1;
-		t = pb->geqs[e].coef[i];
-		pb->geqs[e].coef[i] = pb->geqs[e].coef[j];
-		pb->geqs[e].coef[j] = t;
+		std::swap (pb->geqs[e].coef[i], pb->geqs[e].coef[j]);
 	      }
 
 	  for (e = pb->num_subs - 1; e >= 0; e--)
 	    if (pb->subs[e].coef[i] != pb->subs[e].coef[j])
-	      {
-		t = pb->subs[e].coef[i];
-		pb->subs[e].coef[i] = pb->subs[e].coef[j];
-		pb->subs[e].coef[j] = t;
-	      }
+	      std::swap (pb->subs[e].coef[i], pb->subs[e].coef[j]);
 
 	  if (dump_file && (dump_flags & TDF_DETAILS))
 	    {
@@ -4624,16 +4595,14 @@ omega_solve_geq (omega_pb pb, enum omega_result desired_res)
 	      /* Sort array LOWER_BOUND.  */
 	      for (j = 0; j < lower_bounds; j++)
 		{
-		  int k, smallest = j;
+		  int smallest = j;
 
-		  for (k = j + 1; k < lower_bounds; k++)
+		  for (int k = j + 1; k < lower_bounds; k++)
 		    if (pb->geqs[lower_bound[smallest]].coef[i] >
 			pb->geqs[lower_bound[k]].coef[i])
 		      smallest = k;
 
-		  k = lower_bound[smallest];
-		  lower_bound[smallest] = lower_bound[j];
-		  lower_bound[j] = k;
+		  std::swap (lower_bound[smallest], lower_bound[j]);
 		}
 
 	      if (dump_file && (dump_flags & TDF_DETAILS))
diff --git a/gcc/optabs.c b/gcc/optabs.c
index bd03fc1f5fe..d883b000f04 100644
--- a/gcc/optabs.c
+++ b/gcc/optabs.c
@@ -1418,7 +1418,6 @@ expand_binop_directly (machine_mode mode, optab binoptab,
   bool commutative_p;
   rtx pat;
   rtx xop0 = op0, xop1 = op1;
-  rtx swap;
 
   /* If it is a commutative operator and the modes would match
      if we would swap the operands, we can save the conversions.  */
@@ -1426,11 +1425,7 @@ expand_binop_directly (machine_mode mode, optab binoptab,
   if (commutative_p
       && GET_MODE (xop0) != xmode0 && GET_MODE (xop1) != xmode1
       && GET_MODE (xop0) == xmode1 && GET_MODE (xop1) == xmode1)
-    {
-      swap = xop0;
-      xop0 = xop1;
-      xop1 = swap;
-    }
+    std::swap (xop0, xop1);
 
   /* If we are optimizing, force expensive constants into a register.  */
   xop0 = avoid_expensive_constant (xmode0, binoptab, 0, xop0, unsignedp);
@@ -1463,11 +1458,7 @@ expand_binop_directly (machine_mode mode, optab binoptab,
      Also try to make the last operand a constant.  */
   if (commutative_p
       && swap_commutative_operands_with_target (target, xop0, xop1))
-    {
-      swap = xop1;
-      xop1 = xop0;
-      xop0 = swap;
-    }
+    std::swap (xop0, xop1);
 
   /* Now, if insn's predicates don't allow our operands, put them into
      pseudo regs.  */
@@ -1722,11 +1713,7 @@ expand_binop (machine_mode mode, optab binoptab, rtx op0, rtx op1,
      Also try to make the last operand a constant.  */
   if (commutative_optab_p (binoptab)
       && swap_commutative_operands_with_target (target, op0, op1))
-    {
-      temp = op1;
-      op1 = op0;
-      op0 = temp;
-    }
+    std::swap (op0, op1);
 
   /* These can be done a word at a time.  */
   if ((binoptab == and_optab || binoptab == ior_optab || binoptab == xor_optab)
@@ -4553,7 +4540,7 @@ emit_conditional_move (rtx target, enum rtx_code code, rtx op0, rtx op1,
 		       machine_mode cmode, rtx op2, rtx op3,
 		       machine_mode mode, int unsignedp)
 {
-  rtx tem, comparison;
+  rtx comparison;
   rtx_insn *last;
   enum insn_code icode;
   enum rtx_code reversed;
@@ -4563,9 +4550,7 @@ emit_conditional_move (rtx target, enum rtx_code code, rtx op0, rtx op1,
 
   if (swap_commutative_operands_p (op0, op1))
     {
-      tem = op0;
-      op0 = op1;
-      op1 = tem;
+      std::swap (op0, op1);
       code = swap_condition (code);
     }
 
@@ -4584,9 +4569,7 @@ emit_conditional_move (rtx target, enum rtx_code code, rtx op0, rtx op1,
       && ((reversed = reversed_comparison_code_parts (code, op0, op1, NULL))
           != UNKNOWN))
     {
-      tem = op2;
-      op2 = op3;
-      op3 = tem;
+      std::swap (op2, op3);
       code = reversed;
     }
 
@@ -4675,7 +4658,7 @@ emit_conditional_add (rtx target, enum rtx_code code, rtx op0, rtx op1,
 		      machine_mode cmode, rtx op2, rtx op3,
 		      machine_mode mode, int unsignedp)
 {
-  rtx tem, comparison;
+  rtx comparison;
   rtx_insn *last;
   enum insn_code icode;
 
@@ -4684,9 +4667,7 @@ emit_conditional_add (rtx target, enum rtx_code code, rtx op0, rtx op1,
 
   if (swap_commutative_operands_p (op0, op1))
     {
-      tem = op0;
-      op0 = op1;
-      op1 = tem;
+      std::swap (op0, op1);
       code = swap_condition (code);
     }
 
diff --git a/gcc/postreload.c b/gcc/postreload.c
index 99b1fc26900..b12ef5b1028 100644
--- a/gcc/postreload.c
+++ b/gcc/postreload.c
@@ -632,7 +632,6 @@ reload_cse_simplify_operands (rtx_insn *insn, rtx testreg)
       int best = i;
       int best_reject = alternative_reject[alternative_order[i]];
       int best_nregs = alternative_nregs[alternative_order[i]];
-      int tmp;
 
       for (j = i + 1; j < recog_data.n_alternatives; j++)
 	{
@@ -648,9 +647,7 @@ reload_cse_simplify_operands (rtx_insn *insn, rtx testreg)
 	    }
 	}
 
-      tmp = alternative_order[best];
-      alternative_order[best] = alternative_order[i];
-      alternative_order[i] = tmp;
+      std::swap (alternative_order[best], alternative_order[i]);
     }
 
   /* Substitute the operands as determined by op_alt_regno for the best
diff --git a/gcc/reg-stack.c b/gcc/reg-stack.c
index c5d52c1d686..a8637005dd7 100644
--- a/gcc/reg-stack.c
+++ b/gcc/reg-stack.c
@@ -812,7 +812,7 @@ emit_swap_insn (rtx_insn *insn, stack_ptr regstack, rtx reg)
 {
   int hard_regno;
   rtx swap_rtx;
-  int tmp, other_reg;		/* swap regno temps */
+  int other_reg;		/* swap regno temps */
   rtx_insn *i1;			/* the stack-reg insn prior to INSN */
   rtx i1set = NULL_RTX;		/* the SET rtx within I1 */
 
@@ -833,10 +833,7 @@ emit_swap_insn (rtx_insn *insn, stack_ptr regstack, rtx reg)
   gcc_assert (hard_regno >= FIRST_STACK_REG);
 
   other_reg = regstack->top - (hard_regno - FIRST_STACK_REG);
-
-  tmp = regstack->reg[other_reg];
-  regstack->reg[other_reg] = regstack->reg[regstack->top];
-  regstack->reg[regstack->top] = tmp;
+  std::swap (regstack->reg[regstack->top], regstack->reg[other_reg]);
 
   /* Find the previous insn involving stack regs, but don't pass a
      block boundary.  */
@@ -918,7 +915,7 @@ static void
 swap_to_top (rtx_insn *insn, stack_ptr regstack, rtx src1, rtx src2)
 {
   struct stack_def temp_stack;
-  int regno, j, k, temp;
+  int regno, j, k;
 
   temp_stack = *regstack;
 
@@ -930,9 +927,7 @@ swap_to_top (rtx_insn *insn, stack_ptr regstack, rtx src1, rtx src2)
       k = temp_stack.top - (regno - FIRST_STACK_REG);
       j = temp_stack.top;
 
-      temp = temp_stack.reg[k];
-      temp_stack.reg[k] = temp_stack.reg[j];
-      temp_stack.reg[j] = temp;
+      std::swap (temp_stack.reg[j], temp_stack.reg[k]);
     }
 
   /* Place operand 2 next on the stack.  */
@@ -943,9 +938,7 @@ swap_to_top (rtx_insn *insn, stack_ptr regstack, rtx src1, rtx src2)
       k = temp_stack.top - (regno - FIRST_STACK_REG);
       j = temp_stack.top - 1;
 
-      temp = temp_stack.reg[k];
-      temp_stack.reg[k] = temp_stack.reg[j];
-      temp_stack.reg[j] = temp;
+      std::swap (temp_stack.reg[j], temp_stack.reg[k]);
     }
 
   change_stack (insn, regstack, &temp_stack, EMIT_BEFORE);
@@ -1261,10 +1254,7 @@ compare_for_stack_reg (rtx_insn *insn, stack_ptr regstack, rtx pat_src)
 	   && get_hard_regnum (regstack, *src2) == FIRST_STACK_REG))
       && swap_rtx_condition (insn))
     {
-      rtx temp;
-      temp = XEXP (pat_src, 0);
-      XEXP (pat_src, 0) = XEXP (pat_src, 1);
-      XEXP (pat_src, 1) = temp;
+      std::swap (XEXP (pat_src, 0), XEXP (pat_src, 1));
 
       src1 = get_true_reg (&XEXP (pat_src, 0));
       src2 = get_true_reg (&XEXP (pat_src, 1));
@@ -2139,15 +2129,13 @@ subst_asm_stack_regs (rtx_insn *insn, stack_ptr regstack)
 	       it and swap it with whatever is already in I's place.
 	       K is where recog_data.operand[i] is now.  J is where it
 	       should be.  */
-	    int j, k, temp;
+	    int j, k;
 
 	    k = temp_stack.top - (regno - FIRST_STACK_REG);
 	    j = (temp_stack.top
 		 - (REGNO (recog_data.operand[i]) - FIRST_STACK_REG));
 
-	    temp = temp_stack.reg[k];
-	    temp_stack.reg[k] = temp_stack.reg[j];
-	    temp_stack.reg[j] = temp;
+	    std::swap (temp_stack.reg[j], temp_stack.reg[k]);
 	  }
       }
 
diff --git a/gcc/reload.c b/gcc/reload.c
index dde70b2bcd8..a3edb15d4be 100644
--- a/gcc/reload.c
+++ b/gcc/reload.c
@@ -3064,9 +3064,6 @@ find_reloads (rtx_insn *insn, int replace, int ind_levels, int live_known,
 
 	  if (swapped)
 	    {
-	      enum reg_class tclass;
-	      int t;
-
 	      recog_data.operand[commutative] = substed_operand[commutative + 1];
 	      recog_data.operand[commutative + 1] = substed_operand[commutative];
 	      /* Swap the duplicates too.  */
@@ -3076,17 +3073,12 @@ find_reloads (rtx_insn *insn, int replace, int ind_levels, int live_known,
 		  *recog_data.dup_loc[i]
 		    = recog_data.operand[(int) recog_data.dup_num[i]];
 
-	      tclass = preferred_class[commutative];
-	      preferred_class[commutative] = preferred_class[commutative + 1];
-	      preferred_class[commutative + 1] = tclass;
-
-	      t = pref_or_nothing[commutative];
-	      pref_or_nothing[commutative] = pref_or_nothing[commutative + 1];
-	      pref_or_nothing[commutative + 1] = t;
-
-	      t = address_reloaded[commutative];
-	      address_reloaded[commutative] = address_reloaded[commutative + 1];
-	      address_reloaded[commutative + 1] = t;
+	      std::swap (preferred_class[commutative],
+			 preferred_class[commutative + 1]);
+	      std::swap (pref_or_nothing[commutative],
+			 pref_or_nothing[commutative + 1]);
+	      std::swap (address_reloaded[commutative],
+			 address_reloaded[commutative + 1]);
 	    }
 
 	  this_earlyclobber = 0;
@@ -3818,9 +3810,6 @@ find_reloads (rtx_insn *insn, int replace, int ind_levels, int live_known,
 
 	  if (swapped)
 	    {
-	      enum reg_class tclass;
-	      int t;
-
 	      /* If the commutative operands have been swapped, swap
 		 them back in order to check the next alternative.  */
 	      recog_data.operand[commutative] = substed_operand[commutative];
@@ -3833,17 +3822,12 @@ find_reloads (rtx_insn *insn, int replace, int ind_levels, int live_known,
 		    = recog_data.operand[(int) recog_data.dup_num[i]];
 
 	      /* Unswap the operand related information as well.  */
-	      tclass = preferred_class[commutative];
-	      preferred_class[commutative] = preferred_class[commutative + 1];
-	      preferred_class[commutative + 1] = tclass;
-
-	      t = pref_or_nothing[commutative];
-	      pref_or_nothing[commutative] = pref_or_nothing[commutative + 1];
-	      pref_or_nothing[commutative + 1] = t;
-
-	      t = address_reloaded[commutative];
-	      address_reloaded[commutative] = address_reloaded[commutative + 1];
-	      address_reloaded[commutative + 1] = t;
+	      std::swap (preferred_class[commutative],
+			 preferred_class[commutative + 1]);
+	      std::swap (pref_or_nothing[commutative],
+			 pref_or_nothing[commutative + 1]);
+	      std::swap (address_reloaded[commutative],
+			 address_reloaded[commutative + 1]);
 	    }
 	}
     }
@@ -3892,18 +3876,12 @@ find_reloads (rtx_insn *insn, int replace, int ind_levels, int live_known,
 
   if (goal_alternative_swapped)
     {
-      rtx tem;
-
-      tem = substed_operand[commutative];
-      substed_operand[commutative] = substed_operand[commutative + 1];
-      substed_operand[commutative + 1] = tem;
-      tem = recog_data.operand[commutative];
-      recog_data.operand[commutative] = recog_data.operand[commutative + 1];
-      recog_data.operand[commutative + 1] = tem;
-      tem = *recog_data.operand_loc[commutative];
-      *recog_data.operand_loc[commutative]
-	= *recog_data.operand_loc[commutative + 1];
-      *recog_data.operand_loc[commutative + 1] = tem;
+      std::swap (substed_operand[commutative],
+		 substed_operand[commutative + 1]);
+      std::swap (recog_data.operand[commutative],
+		 recog_data.operand[commutative + 1]);
+      std::swap (*recog_data.operand_loc[commutative],
+		 *recog_data.operand_loc[commutative + 1]);
 
       for (i = 0; i < n_reloads; i++)
 	{
diff --git a/gcc/reload1.c b/gcc/reload1.c
index d2c5524ddcf..3ac8c2da764 100644
--- a/gcc/reload1.c
+++ b/gcc/reload1.c
@@ -5707,18 +5707,15 @@ gen_reload_chain_without_interm_reg_p (int r1, int r2)
   /* Assume other cases in gen_reload are not possible for
      chain reloads or do need an intermediate hard registers.  */
   bool result = true;
-  int regno, n, code;
+  int regno, code;
   rtx out, in;
   rtx_insn *insn;
   rtx_insn *last = get_last_insn ();
 
   /* Make r2 a component of r1.  */
   if (reg_mentioned_p (rld[r1].in, rld[r2].in))
-    {
-      n = r1;
-      r1 = r2;
-      r2 = n;
-    }
+    std::swap (r1, r2);
+
   gcc_assert (reg_mentioned_p (rld[r2].in, rld[r1].in));
   regno = rld[r1].regno >= 0 ? rld[r1].regno : rld[r2].regno;
   gcc_assert (regno >= 0);
diff --git a/gcc/sel-sched.c b/gcc/sel-sched.c
index b8ed356a2a2..6a58b2c4a8a 100644
--- a/gcc/sel-sched.c
+++ b/gcc/sel-sched.c
@@ -4142,16 +4142,12 @@ invoke_reorder_hooks (fence_t fence)
       for (i = 0, n = ready.n_ready; i < n; i++)
         if (EXPR_INSN_RTX (vec[i]) != arr[i])
           {
-            expr_t tmp;
-
             for (j = i; j < n; j++)
               if (EXPR_INSN_RTX (vec[j]) == arr[i])
                 break;
             gcc_assert (j < n);
 
-            tmp = vec[i];
-            vec[i] = vec[j];
-            vec[j] = tmp;
+	    std::swap (vec[i], vec[j]);
           }
     }
 
@@ -4610,15 +4606,12 @@ create_block_for_bookkeeping (edge e1, edge e2)
 	    {
 	      sel_global_bb_info_def gbi;
 	      sel_region_bb_info_def rbi;
-	      int i;
 
 	      if (sched_verbose >= 2)
 		sel_print ("Swapping block ids %i and %i\n",
 			   new_bb->index, succ->index);
 
-	      i = new_bb->index;
-	      new_bb->index = succ->index;
-	      succ->index = i;
+	      std::swap (new_bb->index, succ->index);
 
 	      SET_BASIC_BLOCK_FOR_FN (cfun, new_bb->index, new_bb);
 	      SET_BASIC_BLOCK_FOR_FN (cfun, succ->index, succ);
@@ -4633,15 +4626,13 @@ create_block_for_bookkeeping (edge e1, edge e2)
 		      sizeof (rbi));
 	      memcpy (SEL_REGION_BB_INFO (succ), &rbi, sizeof (rbi));
 
-	      i = BLOCK_TO_BB (new_bb->index);
-	      BLOCK_TO_BB (new_bb->index) = BLOCK_TO_BB (succ->index);
-	      BLOCK_TO_BB (succ->index) = i;
+	      std::swap (BLOCK_TO_BB (new_bb->index),
+			 BLOCK_TO_BB (succ->index));
 
-	      i = CONTAINING_RGN (new_bb->index);
-	      CONTAINING_RGN (new_bb->index) = CONTAINING_RGN (succ->index);
-	      CONTAINING_RGN (succ->index) = i;
+	      std::swap (CONTAINING_RGN (new_bb->index),
+			 CONTAINING_RGN (succ->index));
 
-	      for (i = 0; i < current_nr_blocks; i++)
+	      for (int i = 0; i < current_nr_blocks; i++)
 		if (BB_TO_BLOCK (i) == succ->index)
 		  BB_TO_BLOCK (i) = new_bb->index;
 		else if (BB_TO_BLOCK (i) == new_bb->index)
@@ -4666,10 +4657,8 @@ create_block_for_bookkeeping (edge e1, edge e2)
 			   CODE_LABEL_NUMBER (BB_HEAD (new_bb)),
 			   CODE_LABEL_NUMBER (BB_HEAD (succ)));
 
-	      i = CODE_LABEL_NUMBER (BB_HEAD (new_bb));
-	      CODE_LABEL_NUMBER (BB_HEAD (new_bb))
-		= CODE_LABEL_NUMBER (BB_HEAD (succ));
-	      CODE_LABEL_NUMBER (BB_HEAD (succ)) = i;
+	      std::swap (CODE_LABEL_NUMBER (BB_HEAD (new_bb)),
+			 CODE_LABEL_NUMBER (BB_HEAD (succ)));
 	    }
 	}
     }
diff --git a/gcc/tree-data-ref.c b/gcc/tree-data-ref.c
index 3d1d5f8c0fe..505d63b0083 100644
--- a/gcc/tree-data-ref.c
+++ b/gcc/tree-data-ref.c
@@ -2411,18 +2411,6 @@ lambda_matrix_row_add (lambda_matrix mat, int n, int r1, int r2, int const1)
     mat[r2][i] += const1 * mat[r1][i];
 }
 
-/* Swap rows R1 and R2 in matrix MAT.  */
-
-static void
-lambda_matrix_row_exchange (lambda_matrix mat, int r1, int r2)
-{
-  lambda_vector row;
-
-  row = mat[r1];
-  mat[r1] = mat[r2];
-  mat[r2] = row;
-}
-
 /* Multiply vector VEC1 of length SIZE by a constant CONST1,
    and store the result in VEC2.  */
 
@@ -2503,10 +2491,10 @@ lambda_matrix_right_hermite (lambda_matrix A, int m, int n,
 		  factor = sigma * (a / b);
 
 		  lambda_matrix_row_add (S, n, i, i-1, -factor);
-		  lambda_matrix_row_exchange (S, i, i-1);
+		  std::swap (S[i], S[i-1]);
 
 		  lambda_matrix_row_add (U, m, i, i-1, -factor);
-		  lambda_matrix_row_exchange (U, i, i-1);
+		  std::swap (U[i], U[i-1]);
 		}
 	    }
 	}
diff --git a/gcc/tree-ssa-coalesce.c b/gcc/tree-ssa-coalesce.c
index eeac5a46ab9..b05a86086ef 100644
--- a/gcc/tree-ssa-coalesce.c
+++ b/gcc/tree-ssa-coalesce.c
@@ -433,15 +433,13 @@ sort_coalesce_list (coalesce_list_p cl)
   if (num == 2)
     {
       if (cl->sorted[0]->cost > cl->sorted[1]->cost)
-        {
-	  p = cl->sorted[0];
-	  cl->sorted[0] = cl->sorted[1];
-	  cl->sorted[1] = p;
-	}
+	std::swap (cl->sorted[0], cl->sorted[1]);
       return;
     }
 
-  /* Only call qsort if there are more than 2 items.  */
+  /* Only call qsort if there are more than 2 items.
+     ??? Maybe std::sort will do better, provided that compare_pairs
+     can be inlined.  */
   if (num > 2)
       qsort (cl->sorted, num, sizeof (coalesce_pair_p), compare_pairs);
 }
diff --git a/gcc/tree-ssa-ifcombine.c b/gcc/tree-ssa-ifcombine.c
index 0ac13b565a8..4170c9be3af 100644
--- a/gcc/tree-ssa-ifcombine.c
+++ b/gcc/tree-ssa-ifcombine.c
@@ -438,25 +438,13 @@ ifcombine_ifandif (basic_block inner_cond_bb, bool inner_inv,
 	;
       else if (bits1 == bits2)
 	{
-	  t = name2;
-	  name2 = bits2;
-	  bits2 = t;
-	  t = name1;
-	  name1 = bits1;
-	  bits1 = t;
+	  std::swap (name2, bits2);
+	  std::swap (name1, bits1);
 	}
       else if (name1 == bits2)
-	{
-	  t = name2;
-	  name2 = bits2;
-	  bits2 = t;
-	}
+	std::swap (name2, bits2);
       else if (bits1 == name2)
-	{
-	  t = name1;
-	  name1 = bits1;
-	  bits1 = t;
-	}
+	std::swap (name1, bits1);
       else
 	return false;
 
diff --git a/gcc/tree-ssa-loop-ivopts.c b/gcc/tree-ssa-loop-ivopts.c
index 44219d259e1..3ed32d8e2fb 100644
--- a/gcc/tree-ssa-loop-ivopts.c
+++ b/gcc/tree-ssa-loop-ivopts.c
@@ -5587,7 +5587,6 @@ static struct iv_ca_delta *
 iv_ca_delta_reverse (struct iv_ca_delta *delta)
 {
   struct iv_ca_delta *act, *next, *prev = NULL;
-  struct cost_pair *tmp;
 
   for (act = delta; act; act = next)
     {
@@ -5595,9 +5594,7 @@ iv_ca_delta_reverse (struct iv_ca_delta *delta)
       act->next_change = prev;
       prev = act;
 
-      tmp = act->old_cp;
-      act->old_cp = act->new_cp;
-      act->new_cp = tmp;
+      std::swap (act->old_cp, act->new_cp);
     }
 
   return prev;
diff --git a/gcc/tree-ssa-math-opts.c b/gcc/tree-ssa-math-opts.c
index 11288b1b56b..98e2c495333 100644
--- a/gcc/tree-ssa-math-opts.c
+++ b/gcc/tree-ssa-math-opts.c
@@ -3013,13 +3013,8 @@ is_widening_mult_p (gimple stmt,
   /* Ensure that the larger of the two operands comes first. */
   if (TYPE_PRECISION (*type1_out) < TYPE_PRECISION (*type2_out))
     {
-      tree tmp;
-      tmp = *type1_out;
-      *type1_out = *type2_out;
-      *type2_out = tmp;
-      tmp = *rhs1_out;
-      *rhs1_out = *rhs2_out;
-      *rhs2_out = tmp;
+      std::swap (*type1_out, *type2_out);
+      std::swap (*rhs1_out, *rhs2_out);
     }
 
   return true;
diff --git a/gcc/tree-ssa-phiopt.c b/gcc/tree-ssa-phiopt.c
index 7c846c2b6e2..09d6f674910 100644
--- a/gcc/tree-ssa-phiopt.c
+++ b/gcc/tree-ssa-phiopt.c
@@ -1911,8 +1911,8 @@ hoist_adjacent_loads (basic_block bb0, basic_block bb1,
   for (gsi = gsi_start_phis (bb3); !gsi_end_p (gsi); gsi_next (&gsi))
     {
       gphi *phi_stmt = gsi.phi ();
-      gimple def1, def2, defswap;
-      tree arg1, arg2, ref1, ref2, field1, field2, fieldswap;
+      gimple def1, def2;
+      tree arg1, arg2, ref1, ref2, field1, field2;
       tree tree_offset1, tree_offset2, tree_size2, next;
       int offset1, offset2, size2;
       unsigned align1;
@@ -1987,12 +1987,8 @@ hoist_adjacent_loads (basic_block bb0, basic_block bb1,
 	  if (next != field1)
 	    continue;
 
-	  fieldswap = field1;
-	  field1 = field2;
-	  field2 = fieldswap;
-	  defswap = def1;
-	  def1 = def2;
-	  def2 = defswap;
+	  std::swap (field1, field2);
+	  std::swap (def1, def2);
 	}
 
       bb_for_def1 = gimple_bb (def1);
diff --git a/gcc/tree-ssa-reassoc.c b/gcc/tree-ssa-reassoc.c
index f79303b67e4..0c67379a5be 100644
--- a/gcc/tree-ssa-reassoc.c
+++ b/gcc/tree-ssa-reassoc.c
@@ -4117,8 +4117,6 @@ linearize_expr_tree (vec<operand_entry_t> *ops, gimple stmt,
 
   if (!binlhsisreassoc)
     {
-      tree temp;
-
       /* If this is not a associative operation like division, give up.  */
       if (!is_associative)
 	{
@@ -4170,9 +4168,7 @@ linearize_expr_tree (vec<operand_entry_t> *ops, gimple stmt,
 
       /* We want to make it so the lhs is always the reassociative op,
 	 so swap.  */
-      temp = binlhs;
-      binlhs = binrhs;
-      binrhs = temp;
+      std::swap (binlhs, binrhs);
     }
   else if (binrhsisreassoc)
     {
diff --git a/gcc/tree-ssa-threadedge.c b/gcc/tree-ssa-threadedge.c
index acbbb671dcc..932b443d2cd 100644
--- a/gcc/tree-ssa-threadedge.c
+++ b/gcc/tree-ssa-threadedge.c
@@ -544,11 +544,8 @@ simplify_control_stmt_condition (edge e,
 	 miss threading opportunities.  */
       if (tree_swap_operands_p (op0, op1, false))
 	{
-	  tree tmp;
 	  cond_code = swap_tree_comparison (cond_code);
-	  tmp = op0;
-	  op0 = op1;
-	  op1 = tmp;
+	  std::swap (op0, op1);
 	}
 
       /* Stuff the operator and operands into our dummy conditional
diff --git a/gcc/tree-vrp.c b/gcc/tree-vrp.c
index c0b381df648..22587d00bc5 100644
--- a/gcc/tree-vrp.c
+++ b/gcc/tree-vrp.c
@@ -4556,11 +4556,8 @@ compare_ranges (enum tree_code comp, value_range_t *vr0, value_range_t *vr1,
      operands around and change the comparison code.  */
   if (comp == GT_EXPR || comp == GE_EXPR)
     {
-      value_range_t *tmp;
       comp = (comp == GT_EXPR) ? LT_EXPR : LE_EXPR;
-      tmp = vr0;
-      vr0 = vr1;
-      vr1 = tmp;
+      std::swap (vr0, vr1);
     }
 
   if (comp == EQ_EXPR)
diff --git a/gcc/var-tracking.c b/gcc/var-tracking.c
index 460f6e75278..0db43584f02 100644
--- a/gcc/var-tracking.c
+++ b/gcc/var-tracking.c
@@ -6509,13 +6509,7 @@ add_with_sets (rtx_insn *insn, struct cselib_set *sets, int n_sets)
       while (n1 < n2 && mos[n2].type != MO_USE)
 	n2--;
       if (n1 < n2)
-	{
-	  micro_operation sw;
-
-	  sw = mos[n1];
-	  mos[n1] = mos[n2];
-	  mos[n2] = sw;
-	}
+	std::swap (mos[n1], mos[n2]);
     }
 
   n2 = VTI (bb)->mos.length () - 1;
@@ -6526,13 +6520,7 @@ add_with_sets (rtx_insn *insn, struct cselib_set *sets, int n_sets)
       while (n1 < n2 && mos[n2].type == MO_VAL_LOC)
 	n2--;
       if (n1 < n2)
-	{
-	  micro_operation sw;
-
-	  sw = mos[n1];
-	  mos[n1] = mos[n2];
-	  mos[n2] = sw;
-	}
+	std::swap (mos[n1], mos[n2]);
     }
 
   if (CALL_P (insn))
@@ -6568,13 +6556,7 @@ add_with_sets (rtx_insn *insn, struct cselib_set *sets, int n_sets)
       while (n1 < n2 && mos[n2].type != MO_VAL_USE)
 	n2--;
       if (n1 < n2)
-	{
-	  micro_operation sw;
-
-	  sw = mos[n1];
-	  mos[n1] = mos[n2];
-	  mos[n2] = sw;
-	}
+	std::swap (mos[n1], mos[n2]);
     }
 
   n2 = VTI (bb)->mos.length () - 1;
@@ -6585,13 +6567,7 @@ add_with_sets (rtx_insn *insn, struct cselib_set *sets, int n_sets)
       while (n1 < n2 && mos[n2].type != MO_CLOBBER)
 	n2--;
       if (n1 < n2)
-	{
-	  micro_operation sw;
-
-	  sw = mos[n1];
-	  mos[n1] = mos[n2];
-	  mos[n2] = sw;
-	}
+	std::swap (mos[n1], mos[n2]);
     }
 }
 
@@ -6982,8 +6958,7 @@ vt_find_locations (void)
 {
   bb_heap_t *worklist = new bb_heap_t (LONG_MIN);
   bb_heap_t *pending = new bb_heap_t (LONG_MIN);
-  bb_heap_t *fibheap_swap = NULL;
-  sbitmap visited, in_worklist, in_pending, sbitmap_swap;
+  sbitmap visited, in_worklist, in_pending;
   basic_block bb;
   edge e;
   int *bb_order;
@@ -7014,12 +6989,8 @@ vt_find_locations (void)
 
   while (success && !pending->empty ())
     {
-      fibheap_swap = pending;
-      pending = worklist;
-      worklist = fibheap_swap;
-      sbitmap_swap = in_pending;
-      in_pending = in_worklist;
-      in_worklist = sbitmap_swap;
+      std::swap (worklist, pending);
+      std::swap (in_worklist, in_pending);
 
       bitmap_clear (visited);