MIPS: Use AST's type field and merge types for unary, binary & compare ICs.

src/mips/lithium-codegen-mips.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 1118 matching lines @@
         DeoptimizeIf(eq, instr->environment(), result_reg, Operand(zero_reg));
       }
       __ Branch(USE_DELAY_SLOT, &done);
       __ subu(result_reg, zero_reg, result_reg);
     }
 
     __ bind(&left_is_not_negative);
     __ And(result_reg, scratch, divisor - 1);
     __ bind(&done);
 
-  } else {
-    // TODO(svenpanne) Add right->has_fixed_right_arg() case.
-
+  } else if (hmod->fixed_right_arg().has_value) {
     const Register scratch = scratch0();
     const Register left_reg = ToRegister(instr->left());
     const Register result_reg = ToRegister(instr->result());
+
+    Register right_reg = EmitLoadRegister(instr->right(), scratch);
+
+    int32_t divisor = hmod->fixed_right_arg().value;
+    ASSERT(IsPowerOf2(divisor));
+
+    // Check if our assumption of a fixed right operand still holds.
+    DeoptimizeIf(ne, instr->environment(), right_reg, Operand(divisor));
+
+    Label left_is_not_negative, done;
+    if (left->CanBeNegative()) {
+      __ Branch(USE_DELAY_SLOT, &left_is_not_negative,
+                ge, left_reg, Operand(zero_reg));
+      __ subu(result_reg, zero_reg, left_reg);
+      __ And(result_reg, result_reg, divisor - 1);
+      if (hmod->CheckFlag(HValue::kBailoutOnMinusZero)) {
+        DeoptimizeIf(eq, instr->environment(), result_reg, Operand(zero_reg));
+      }
+      __ Branch(USE_DELAY_SLOT, &done);
+      __ subu(result_reg, zero_reg, result_reg);
+    }
+
+    __ bind(&left_is_not_negative);
+    __ And(result_reg, left_reg, divisor - 1);
+    __ bind(&done);
+
+  } else {
+    const Register scratch = scratch0();
+    const Register left_reg = ToRegister(instr->left());
+    const Register result_reg = ToRegister(instr->result());
 
     // div runs in the background while we check for special cases.
     Register right_reg = EmitLoadRegister(instr->right(), scratch);
     __ div(left_reg, right_reg);
 
     Label done;
     // Check for x % 0, we have to deopt in this case because we can't return a
     // NaN.
     if (right->CanBeZero()) {
       DeoptimizeIf(eq, instr->environment(), right_reg, Operand(zero_reg));
@@ skipping 4735 matching lines @@
   __ Subu(scratch, result, scratch);
   __ lw(result, FieldMemOperand(scratch,
                                 FixedArray::kHeaderSize - kPointerSize));
   __ bind(&done);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal