Clean up code to clarify we are only tracking the condition flags of APSR.

src/trusted/validator_arm/actual_classes.cc

 /*
  * Copyright (c) 2012 The Native Client Authors. All rights reserved.
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "native_client/src/trusted/validator_arm/actual_classes.h"
 
 #include <assert.h>
 #include <string.h>
 
 // Implementations of instruction classes, for those not completely defined in
 // in the header.
 
 namespace nacl_arm_dec {
 
 // **************************************************************
 //      N E W    C L A S S    D E C O D E R S
 // **************************************************************
 
-// Data processing and arithmetic
+// Defs12To15
 SafetyLevel Defs12To15::safety(const Instruction i) const {
   if (defs(i)[kRegisterPc]) {
     return FORBIDDEN_OPERANDS;
   }
   return MAY_BE_SAFE;
 }
 
 RegisterList Defs12To15::defs(const Instruction i) const {
-  return d.reg(i) + flags.reg_if_updated(i);
+  return d.reg(i) + conditions.conds_if_updated(i);
 }
 
 SafetyLevel Defs12To15RdRnRsRmNotPc::safety(const Instruction i) const {
   if ((d.reg(i) + n.reg(i) + s.reg(i) + m.reg(i))[kRegisterPc])
     return UNPREDICTABLE;
 
   // Note: We would restrict out PC as well for Rd in NaCl, but no need
   // since the ARM restriction doesn't allow it anyway.
   return MAY_BE_SAFE;
 }
@@ skipping 12 matching lines @@
 
 // Data processing and arithmetic
 SafetyLevel DataProc::safety(const Instruction i) const {
   if (defs(i)[kRegisterPc]) {
     return FORBIDDEN_OPERANDS;
   }
   return MAY_BE_SAFE;
 }
 
 RegisterList DataProc::defs(const Instruction i) const {
-  return Rd(i) + (UpdatesFlagsRegister(i) ? kRegisterFlags : kRegisterNone);
+  return Rd(i) + (UpdatesConditions(i) ? kConditions : kRegisterNone);
 }
 
 RegisterList Test::defs(const Instruction i) const {
-  return (UpdatesFlagsRegister(i) ? kRegisterFlags : kRegisterNone);
+  return (UpdatesConditions(i) ? kConditions : kRegisterNone);
 }
 
 
 bool TestImmediate::sets_Z_if_bits_clear(Instruction i,
                                          Register r,
                                          uint32_t mask) const {
   // Rn = 19:16 for TST(immediate) - section A8.6.230
   return Rn(i) == r
       && (imm12.get_modified_immediate(i) & mask) == mask
-      && defs(i)[kRegisterFlags];
+      && defs(i)[kConditions];
 }
 
 
 bool ImmediateBic::clears_bits(const Instruction i, uint32_t mask) const {
   return (imm12.get_modified_immediate(i) & mask) == mask;
 }
 
 
 SafetyLevel PackSatRev::safety(const Instruction i) const {
   if (defs(i)[kRegisterPc]) {
     return FORBIDDEN_OPERANDS;
   }
   return MAY_BE_SAFE;
 }
 
 RegisterList PackSatRev::defs(const Instruction i) const {
-  return Rd(i) + kRegisterFlags;
+  return Rd(i) + kConditions;
 }
 
 
 SafetyLevel Multiply::safety(const Instruction i) const {
   if (defs(i)[kRegisterPc]) {
     return FORBIDDEN_OPERANDS;
   }
   return MAY_BE_SAFE;
 }
 
 RegisterList Multiply::defs(const Instruction i) const {
-  return kRegisterFlags + Rd(i);
+  return kConditions + Rd(i);
 }
 
 
 RegisterList LongMultiply::defs(const Instruction i) const {
   return RdHi(i) + RdLo(i);
 }
 
 
 RegisterList SatAddSub::defs(const Instruction i) const {
-  return DataProc::defs(i) + kRegisterFlags;
+  return DataProc::defs(i) + kConditions;
 }
 
 
 // MSR
 
 RegisterList MoveToStatusRegister::defs(const Instruction i) const {
   UNREFERENCED_PARAMETER(i);
-  return kRegisterFlags;
+  return kConditions;
 }
 
 
 // Stores
 
 SafetyLevel StoreImmediate::safety(const Instruction i) const {
   // Don't let addressing writeback alter PC.
   if (defs(i)[kRegisterPc]) return FORBIDDEN_OPERANDS;
 
   return MAY_BE_SAFE;
@@ skipping 326 matching lines @@
   return kRegisterPc + (PreindexingFlag(i) ? kRegisterLink : kRegisterNone);
 }
 
 int32_t Branch::branch_target_offset(const Instruction i) const {
   // Sign extend and shift left 2:
   int32_t offset = (int32_t)(i.bits(23, 0) << 8) >> 6;
   return offset + 8;  // because r15 reads as 8 bytes ahead
 }
 
 }  // namespace