diff --git a/gcc/loop-invariant.c b/gcc/loop-invariant.c
index 25e63e4..ef5c59b 100644
--- a/gcc/loop-invariant.c
+++ b/gcc/loop-invariant.c
@@ -1090,16 +1090,22 @@ get_pressure_class_and_nregs (rtx insn, int *nregs)
 }

 /* Calculates cost and number of registers needed for moving invariant INV
-   out of the loop and stores them to *COST and *REGS_NEEDED.  */
+   out of the loop and stores them to *COST and *REGS_NEEDED.  *CL will be
+   the REG_CLASS of INV.  Return
+     -1: if INV is invalid.
+      0: if INV and its depends_on have same reg_class
+      1: if INV and its depends_on have different reg_classes.  */

-static void
-get_inv_cost (struct invariant *inv, int *comp_cost, unsigned *regs_needed)
+static int
+get_inv_cost (struct invariant *inv, int *comp_cost, unsigned *regs_needed,
+             enum reg_class *cl)
 {
   int i, acomp_cost;
   unsigned aregs_needed[N_REG_CLASSES];
   unsigned depno;
   struct invariant *dep;
   bitmap_iterator bi;
+  int ret = 1;

   /* Find the representative of the class of the equivalent invariants.  */
   inv = invariants[inv->eqto];
@@ -1115,7 +1121,7 @@ get_inv_cost (struct invariant *inv, int
*comp_cost, unsigned *regs_needed)

   if (inv->move
       || inv->stamp == actual_stamp)
-    return;
+    return -1;
   inv->stamp = actual_stamp;

   if (! flag_ira_loop_pressure)
@@ -1127,6 +1133,8 @@ get_inv_cost (struct invariant *inv, int
*comp_cost, unsigned *regs_needed)

       pressure_class = get_pressure_class_and_nregs (inv->insn, &nregs);
       regs_needed[pressure_class] += nregs;
+      *cl = pressure_class;
+      ret = 0;
     }

   if (!inv->cheap_address
@@ -1167,6 +1175,8 @@ get_inv_cost (struct invariant *inv, int
*comp_cost, unsigned *regs_needed)
   EXECUTE_IF_SET_IN_BITMAP (inv->depends_on, 0, depno, bi)
     {
       bool check_p;
+      enum reg_class dep_cl = ALL_REGS;
+      int dep_ret;

       dep = invariants[depno];

@@ -1174,7 +1184,7 @@ get_inv_cost (struct invariant *inv, int
*comp_cost, unsigned *regs_needed)
       if (dep->move)
        continue;

-      get_inv_cost (dep, &acomp_cost, aregs_needed);
+      dep_ret = get_inv_cost (dep, &acomp_cost, aregs_needed, &dep_cl);

       if (! flag_ira_loop_pressure)
        check_p = aregs_needed[0] != 0;
@@ -1184,6 +1194,12 @@ get_inv_cost (struct invariant *inv, int
*comp_cost, unsigned *regs_needed)
            if (aregs_needed[ira_pressure_classes[i]] != 0)
              break;
          check_p = i < ira_pressure_classes_num;
+
+         if ((dep_ret == 1) || ((dep_ret == 0) && (*cl != dep_cl)))
+           {
+             *cl = ALL_REGS;
+             ret = 1;
+           }
        }
       if (check_p
          /* We need to check always_executed, since if the original value of
@@ -1217,6 +1233,7 @@ get_inv_cost (struct invariant *inv, int
*comp_cost, unsigned *regs_needed)
        }
       (*comp_cost) += acomp_cost;
     }
+  return ret;
 }

 /* Calculates gain for eliminating invariant INV.  REGS_USED is the number
@@ -1231,10 +1248,12 @@ gain_for_invariant (struct invariant *inv,
unsigned *regs_needed,
                    bool speed, bool call_p)
 {
   int comp_cost, size_cost;
+  enum reg_class cl;
+  int ret;

   actual_stamp++;

-  get_inv_cost (inv, &comp_cost, regs_needed);
+  ret = get_inv_cost (inv, &comp_cost, regs_needed, &cl);

   if (! flag_ira_loop_pressure)
     {
@@ -1243,6 +1262,11 @@ gain_for_invariant (struct invariant *inv,
unsigned *regs_needed,
                   - estimate_reg_pressure_cost (new_regs[0],
                                                 regs_used, speed, call_p));
     }
+  else if (ret < 0)
+    return -1;
+  else if ((ret == 0) && (cl == NO_REGS))
+    /* Hoist it anyway since it does not impact register pressure.  */
+    return 1;
   else
     {
       int i;
@@ -1251,6 +1275,10 @@ gain_for_invariant (struct invariant *inv,
unsigned *regs_needed,
       for (i = 0; i < ira_pressure_classes_num; i++)
        {
          pressure_class = ira_pressure_classes[i];
+
+         if (!reg_classes_intersect_p (pressure_class, cl))
+           continue;
+
          if ((int) new_regs[pressure_class]
              + (int) regs_needed[pressure_class]
              + LOOP_DATA (curr_loop)->max_reg_pressure[pressure_class]
diff --git a/gcc/testsuite/gcc.dg/ira-loop-pressure.c
b/gcc/testsuite/gcc.dg/ira-loop-pressure.c
new file mode 100644
index 0000000..7ef4fa7
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/ira-loop-pressure.c
@@ -0,0 +1,32 @@
+/* Loop2_invariants pass should distinguish register pressures of different
+   register classes.  In this case, register pressue of INT is high.  But
+   we can still move the FP invariant out of the loop.  */
+
+/* { dg-do compile { target { x86_64-*-* && lp64 } } } */
+/* { dg-options "-O2 -fira-loop-pressure -fdump-rtl-loop2_invariant " } */
+
+float tt;
+extern void foo2 (int *, int *, int *, int *, int *, int *);
+extern int foo3 (int, int, int, int, int, int);
+int foo (int a, int b, int c, int d)
+{
+   int i = a;
+   int t1, t2, t3, t4, t5, t6;
+   t1 = t2 = t3 = t4 = t5 = t6 = 0;
+
+   for (; i > 0; i += c)
+    {
+      tt += 123456.0;
+      if (d > t1 + t2)
+       tt = 3.0;
+      foo2 (&t1, &t2, &t3, &t4, &t5, &t6);
+      t1 += t3 + t4 + a + b;
+      t2 -= t5 - t6 - c - d;
+    }
+
+ return foo3 (t1, t2, t3, t4, t5, t6);
+}
+
+/* { dg-final { scan-rtl-dump "Decided to move invariant"
"loop2_invariant"  } } */
+/* { dg-final { cleanup-rtl-dump "loop2_invariant" } } */
