ART: Clean up Thumb2Assembler's AddConstant().

Change-Id: I6a4c32d1bba79879e5514059df6336dc331246c1

5 files changed, 28 insertions, 92 deletions

diff --git a/compiler/utils/arm/assembler_arm.h b/compiler/utils/arm/assembler_arm.h
index 7825457d5c..dbcaab98e7 100644
--- a/compiler/utils/arm/assembler_arm.h
+++ b/compiler/utils/arm/assembler_arm.h
@@ -668,11 +668,14 @@ class ArmAssembler : public Assembler {
   virtual void LoadLiteral(DRegister dd, Literal* literal) = 0;
 
   // Add signed constant value to rd. May clobber IP.
-  virtual void AddConstant(Register rd, int32_t value, Condition cond = AL) = 0;
   virtual void AddConstant(Register rd, Register rn, int32_t value,
-                           Condition cond = AL) = 0;
-  virtual void AddConstantSetFlags(Register rd, Register rn, int32_t value,
-                                   Condition cond = AL) = 0;
+                           Condition cond = AL, SetCc set_cc = kCcDontCare) = 0;
+  void AddConstantSetFlags(Register rd, Register rn, int32_t value, Condition cond = AL) {
+    AddConstant(rd, rn, value, cond, kCcSet);
+  }
+  void AddConstant(Register rd, int32_t value, Condition cond = AL, SetCc set_cc = kCcDontCare) {
+    AddConstant(rd, rd, value, cond, set_cc);
+  }
 
   // Load and Store. May clobber IP.
   virtual void LoadImmediate(Register rd, int32_t value, Condition cond = AL) = 0;
diff --git a/compiler/utils/arm/assembler_arm32.cc b/compiler/utils/arm/assembler_arm32.cc
index d91ddee9b9..184d8a5d27 100644
--- a/compiler/utils/arm/assembler_arm32.cc
+++ b/compiler/utils/arm/assembler_arm32.cc
@@ -1321,16 +1321,12 @@ void Arm32Assembler::LoadLiteral(DRegister dd ATTRIBUTE_UNUSED,
   UNREACHABLE();
 }
 
-void Arm32Assembler::AddConstant(Register rd, int32_t value, Condition cond) {
-  AddConstant(rd, rd, value, cond);
-}
-
 
 void Arm32Assembler::AddConstant(Register rd, Register rn, int32_t value,
-                                 Condition cond) {
-  if (value == 0) {
+                                 Condition cond, SetCc set_cc) {
+  if (value == 0 && set_cc != kCcSet) {
     if (rd != rn) {
-      mov(rd, ShifterOperand(rn), cond);
+      mov(rd, ShifterOperand(rn), cond, set_cc);
     }
     return;
   }
@@ -1339,55 +1335,29 @@ void Arm32Assembler::AddConstant(Register rd, Register rn, int32_t value,
   // the readability of generated code for some constants.
   ShifterOperand shifter_op;
   if (ShifterOperandCanHoldArm32(value, &shifter_op)) {
-    add(rd, rn, shifter_op, cond);
+    add(rd, rn, shifter_op, cond, set_cc);
   } else if (ShifterOperandCanHoldArm32(-value, &shifter_op)) {
-    sub(rd, rn, shifter_op, cond);
+    sub(rd, rn, shifter_op, cond, set_cc);
   } else {
     CHECK(rn != IP);
     if (ShifterOperandCanHoldArm32(~value, &shifter_op)) {
-      mvn(IP, shifter_op, cond);
-      add(rd, rn, ShifterOperand(IP), cond);
+      mvn(IP, shifter_op, cond, kCcKeep);
+      add(rd, rn, ShifterOperand(IP), cond, set_cc);
     } else if (ShifterOperandCanHoldArm32(~(-value), &shifter_op)) {
-      mvn(IP, shifter_op, cond);
-      sub(rd, rn, ShifterOperand(IP), cond);
+      mvn(IP, shifter_op, cond, kCcKeep);
+      sub(rd, rn, ShifterOperand(IP), cond, set_cc);
     } else {
       movw(IP, Low16Bits(value), cond);
       uint16_t value_high = High16Bits(value);
       if (value_high != 0) {
         movt(IP, value_high, cond);
       }
-      add(rd, rn, ShifterOperand(IP), cond);
+      add(rd, rn, ShifterOperand(IP), cond, set_cc);
     }
   }
 }
 
 
-void Arm32Assembler::AddConstantSetFlags(Register rd, Register rn, int32_t value,
-                                         Condition cond) {
-  ShifterOperand shifter_op;
-  if (ShifterOperandCanHoldArm32(value, &shifter_op)) {
-    add(rd, rn, shifter_op, cond, kCcSet);
-  } else if (ShifterOperandCanHoldArm32(-value, &shifter_op)) {
-    sub(rd, rn, shifter_op, cond, kCcSet);
-  } else {
-    CHECK(rn != IP);
-    if (ShifterOperandCanHoldArm32(~value, &shifter_op)) {
-      mvn(IP, shifter_op, cond);
-      add(rd, rn, ShifterOperand(IP), cond, kCcSet);
-    } else if (ShifterOperandCanHoldArm32(~(-value), &shifter_op)) {
-      mvn(IP, shifter_op, cond);
-      sub(rd, rn, ShifterOperand(IP), cond, kCcSet);
-    } else {
-      movw(IP, Low16Bits(value), cond);
-      uint16_t value_high = High16Bits(value);
-      if (value_high != 0) {
-        movt(IP, value_high, cond);
-      }
-      add(rd, rn, ShifterOperand(IP), cond, kCcSet);
-    }
-  }
-}
-
 void Arm32Assembler::LoadImmediate(Register rd, int32_t value, Condition cond) {
   ShifterOperand shifter_op;
   if (ShifterOperandCanHoldArm32(value, &shifter_op)) {
diff --git a/compiler/utils/arm/assembler_arm32.h b/compiler/utils/arm/assembler_arm32.h
index b96bb74182..17c6747f0b 100644
--- a/compiler/utils/arm/assembler_arm32.h
+++ b/compiler/utils/arm/assembler_arm32.h
@@ -254,11 +254,8 @@ class Arm32Assembler FINAL : public ArmAssembler {
   void LoadLiteral(DRegister dd, Literal* literal) OVERRIDE;
 
   // Add signed constant value to rd. May clobber IP.
-  void AddConstant(Register rd, int32_t value, Condition cond = AL) OVERRIDE;
   void AddConstant(Register rd, Register rn, int32_t value,
-                   Condition cond = AL) OVERRIDE;
-  void AddConstantSetFlags(Register rd, Register rn, int32_t value,
-                           Condition cond = AL) OVERRIDE;
+                   Condition cond = AL, SetCc set_cc = kCcDontCare) OVERRIDE;
 
   // Load and Store. May clobber IP.
   void LoadImmediate(Register rd, int32_t value, Condition cond = AL) OVERRIDE;
diff --git a/compiler/utils/arm/assembler_thumb2.cc b/compiler/utils/arm/assembler_thumb2.cc
index 90ed10c498..b677789cc9 100644
--- a/compiler/utils/arm/assembler_thumb2.cc
+++ b/compiler/utils/arm/assembler_thumb2.cc
@@ -3192,14 +3192,10 @@ void Thumb2Assembler::LoadLiteral(DRegister dd, Literal* literal) {
   DCHECK_EQ(location + GetFixup(fixup_id)->GetSizeInBytes(), buffer_.Size());
 }
 
-void Thumb2Assembler::AddConstant(Register rd, int32_t value, Condition cond) {
-  AddConstant(rd, rd, value, cond);
-}
-
 
 void Thumb2Assembler::AddConstant(Register rd, Register rn, int32_t value,
-                                  Condition cond) {
-  if (value == 0) {
+                                  Condition cond, SetCc set_cc) {
+  if (value == 0 && set_cc != kCcSet) {
     if (rd != rn) {
       mov(rd, ShifterOperand(rn), cond);
     }
@@ -3210,51 +3206,24 @@ void Thumb2Assembler::AddConstant(Register rd, Register rn, int32_t value,
   // the readability of generated code for some constants.
   ShifterOperand shifter_op;
   if (ShifterOperandCanHold(rd, rn, ADD, value, &shifter_op)) {
-    add(rd, rn, shifter_op, cond);
+    add(rd, rn, shifter_op, cond, set_cc);
   } else if (ShifterOperandCanHold(rd, rn, SUB, -value, &shifter_op)) {
-    sub(rd, rn, shifter_op, cond);
-  } else {
-    CHECK(rn != IP);
-    if (ShifterOperandCanHold(rd, rn, MVN, ~value, &shifter_op)) {
-      mvn(IP, shifter_op, cond);
-      add(rd, rn, ShifterOperand(IP), cond);
-    } else if (ShifterOperandCanHold(rd, rn, MVN, ~(-value), &shifter_op)) {
-      mvn(IP, shifter_op, cond);
-      sub(rd, rn, ShifterOperand(IP), cond);
-    } else {
-      movw(IP, Low16Bits(value), cond);
-      uint16_t value_high = High16Bits(value);
-      if (value_high != 0) {
-        movt(IP, value_high, cond);
-      }
-      add(rd, rn, ShifterOperand(IP), cond);
-    }
-  }
-}
-
-
-void Thumb2Assembler::AddConstantSetFlags(Register rd, Register rn, int32_t value,
-                                          Condition cond) {
-  ShifterOperand shifter_op;
-  if (ShifterOperandCanHold(rd, rn, ADD, value, &shifter_op)) {
-    add(rd, rn, shifter_op, cond, kCcSet);
-  } else if (ShifterOperandCanHold(rd, rn, ADD, -value, &shifter_op)) {
-    sub(rd, rn, shifter_op, cond, kCcSet);
+    sub(rd, rn, shifter_op, cond, set_cc);
   } else {
     CHECK(rn != IP);
     if (ShifterOperandCanHold(rd, rn, MVN, ~value, &shifter_op)) {
-      mvn(IP, shifter_op, cond);
-      add(rd, rn, ShifterOperand(IP), cond, kCcSet);
+      mvn(IP, shifter_op, cond, kCcKeep);
+      add(rd, rn, ShifterOperand(IP), cond, set_cc);
     } else if (ShifterOperandCanHold(rd, rn, MVN, ~(-value), &shifter_op)) {
-      mvn(IP, shifter_op, cond);
-      sub(rd, rn, ShifterOperand(IP), cond, kCcSet);
+      mvn(IP, shifter_op, cond, kCcKeep);
+      sub(rd, rn, ShifterOperand(IP), cond, set_cc);
     } else {
       movw(IP, Low16Bits(value), cond);
       uint16_t value_high = High16Bits(value);
       if (value_high != 0) {
         movt(IP, value_high, cond);
       }
-      add(rd, rn, ShifterOperand(IP), cond, kCcSet);
+      add(rd, rn, ShifterOperand(IP), cond, set_cc);
     }
   }
 }
diff --git a/compiler/utils/arm/assembler_thumb2.h b/compiler/utils/arm/assembler_thumb2.h
index c802c27ea6..6dee68e76f 100644
--- a/compiler/utils/arm/assembler_thumb2.h
+++ b/compiler/utils/arm/assembler_thumb2.h
@@ -297,11 +297,8 @@ class Thumb2Assembler FINAL : public ArmAssembler {
   void LoadLiteral(DRegister dd, Literal* literal) OVERRIDE;
 
   // Add signed constant value to rd. May clobber IP.
-  void AddConstant(Register rd, int32_t value, Condition cond = AL) OVERRIDE;
   void AddConstant(Register rd, Register rn, int32_t value,
-                   Condition cond = AL) OVERRIDE;
-  void AddConstantSetFlags(Register rd, Register rn, int32_t value,
-                           Condition cond = AL) OVERRIDE;
+                   Condition cond = AL, SetCc set_cc = kCcDontCare) OVERRIDE;
 
   // Load and Store. May clobber IP.
   void LoadImmediate(Register rd, int32_t value, Condition cond = AL) OVERRIDE;