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

src/trusted/validator_arm/validator.h

 /*
  * 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.
  */
 
 #ifndef NATIVE_CLIENT_SRC_TRUSTED_VALIDATOR_ARM_V2_VALIDATOR_H
 #define NATIVE_CLIENT_SRC_TRUSTED_VALIDATOR_ARM_V2_VALIDATOR_H
 
 /*
@@ skipping 206 matching lines @@
    * 'this' produces a sandboxed value that 'other' must consume.
    *
    * Note: This function is conservative in that if it isn't sure whether
    * this instruction changes the condition, it assumes that it does.
    *
    * Note that this function can't see the bundle size, so this result does not
    * take it into account.  The SfiValidator reasons on this separately.
    */
   bool always_precedes(const DecodedInstruction &other) const {
     return inst_.condition() == other.inst_.condition() &&
-        !defines(nacl_arm_dec::kRegisterFlags);
+        !defines(nacl_arm_dec::kConditions);
   }
 
   /*
    * Checks that 'this' always follows 'other' -- meaning that if 'other'
    * executes, 'this' is guaranteed to follow.  This is important if 'other'
    * produces an unsafe value that 'this' fixes before it can leak out.
    *
    * Note: This function is conservative in that if it isn't sure whether the
    * other instruction changes the codntion, it assumes that it does.
    *
    * Note that this function can't see the bundle size, so this result does not
    * take it into account.  The SfiValidator reasons on this separately.
    */
   bool always_follows(const DecodedInstruction &other) const {
     return other.always_precedes(*this);
   }
 
   /*
    * Checks that the execution of 'this' is conditional on the test result
    * (specifically, the Z flag being set) from 'other' -- which must be
    * adjacent for this simple check to be meaningful.
    */
   bool is_conditional_on(const DecodedInstruction &other) const {
     return inst_.condition() == nacl_arm_dec::Instruction::EQ
         && other.inst_.condition() == nacl_arm_dec::Instruction::AL
-        && other.defines(nacl_arm_dec::kRegisterFlags);
+        && other.defines(nacl_arm_dec::kConditions);
   }
 
   // The methods below mirror those on ClassDecoder, but are cached and cheap.
   nacl_arm_dec::SafetyLevel safety() const { return safety_; }
   nacl_arm_dec::RegisterList defs() const { return defs_; }
 
   // The methods below pull values from ClassDecoder on demand.
   bool is_relative_branch() const {
     return decoder_->is_relative_branch(inst_);
   }
@@ skipping 152 matching lines @@
 const char * const kProblemReadOnlyRegister = "kProblemReadOnlyRegister";
 // A pseudo-op pattern crosses a bundle boundary.
 const char * const kProblemPatternCrossesBundle =
     "kProblemPatternCrossesBundle";
 // A linking branch instruction is not in the last bundle slot.
 const char * const kProblemMisalignedCall = "kProblemMisalignedCall";
 
 }  // namespace
 
 #endif  // NATIVE_CLIENT_SRC_TRUSTED_VALIDATOR_ARM_V2_VALIDATOR_H