Thumb2 Backend: Make arithmetic instructions set condition codes by default

src/arm/code-stubs-arm.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 655 matching lines @@
   // the_int_ has the answer which is a signed int32 but not a Smi.
   // We test for the special value that has a different exponent.  This test
   // has the neat side effect of setting the flags according to the sign.
   STATIC_ASSERT(HeapNumber::kSignMask == 0x80000000u);
   __ cmp(the_int_, Operand(0x80000000u));
   __ b(eq, &max_negative_int);
   // Set up the correct exponent in scratch_.  All non-Smi int32s have the same.
   // A non-Smi integer is 1.xxx * 2^30 so the exponent is 30 (biased).
   uint32_t non_smi_exponent =
       (HeapNumber::kExponentBias + 30) << HeapNumber::kExponentShift;
-  __ mov(scratch_, Operand(non_smi_exponent));
+  __ mov(scratch_, Operand(non_smi_exponent), LeaveCC);
   // Set the sign bit in scratch_ if the value was negative.
   __ orr(scratch_, scratch_, Operand(HeapNumber::kSignMask), LeaveCC, cs);
   // Subtract from 0 if the value was negative.
   __ rsb(the_int_, the_int_, Operand::Zero(), LeaveCC, cs);
   // We should be masking the implict first digit of the mantissa away here,
   // but it just ends up combining harmlessly with the last digit of the
   // exponent that happens to be 1.  The sign bit is 0 so we shift 10 to get
   // the most significant 1 to hit the last bit of the 12 bit sign and exponent.
   ASSERT(((1 << HeapNumber::kExponentShift) & non_smi_exponent) != 0);
   const int shift_distance = HeapNumber::kNonMantissaBitsInTopWord - 2;
@@ skipping 4114 matching lines @@
     __ add(count, count, Operand(count), SetCC);
   } else {
     __ cmp(count, Operand::Zero());
   }
   __ b(eq, &done);
 
   // Assume that you cannot read (or write) unaligned.
   Label byte_loop;
   // Must copy at least eight bytes, otherwise just do it one byte at a time.
   __ cmp(count, Operand(8));
-  __ add(count, dest, Operand(count));
+  __ add(count, dest, Operand(count), LeaveCC);
   Register limit = count;  // Read until src equals this.
   __ b(lt, &byte_loop);
 
   if (!dest_always_aligned) {
     // Align dest by byte copying. Copies between zero and three bytes.
     __ and_(scratch4, dest, Operand(kReadAlignmentMask), SetCC);
     Label dest_aligned;
     __ b(eq, &dest_aligned);
     __ cmp(scratch4, Operand(2));
     __ ldrb(scratch1, MemOperand(src, 1, PostIndex));
@@ skipping 1525 matching lines @@
     ASSERT(!elements.is(r1));
     __ Move(r1, name);
     __ Move(r0, elements);
   } else {
     __ Move(r0, elements);
     __ Move(r1, name);
   }
   NameDictionaryLookupStub stub(POSITIVE_LOOKUP);
   __ CallStub(&stub);
   __ cmp(r0, Operand::Zero());
-  __ mov(scratch2, Operand(r2));
+  __ mov(scratch2, Operand(r2), LeaveCC);
   __ ldm(ia_w, sp, spill_mask);
 
   __ b(ne, done);
   __ b(eq, miss);
 }
 
 
 void NameDictionaryLookupStub::Generate(MacroAssembler* masm) {
   // This stub overrides SometimesSetsUpAFrame() to return false.  That means
   // we cannot call anything that could cause a GC from this stub.
@@ skipping 809 matching lines @@
   __ bind(&fast_elements_case);
   GenerateCase(masm, FAST_ELEMENTS);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_ARM