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

src/trusted/validator_arm/inst_classes.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_INST_CLASSES_H_
 #define NATIVE_CLIENT_SRC_TRUSTED_VALIDATOR_ARM_INST_CLASSES_H_
 
 #include <stdint.h>
@@ skipping 205 matching lines @@
   inline Imm4Bits16To19Interface() {}
   static inline uint32_t value(const Instruction& i) {
     return i.bits(19, 16);
   }
 
  private:
   NACL_DISALLOW_COPY_AND_ASSIGN(Imm4Bits16To19Interface);
 };
 
 // Interface class to pull out S (update) bit from bit 20, which
-// defines if the flags register is updated by the instruction.
-class UpdatesFlagsRegisterBit20Interface {
+// defines if the condition bits in APSR are updated by the instruction.
+class UpdatesConditionsBit20Interface {
  public:
-  inline UpdatesFlagsRegisterBit20Interface() {}
-  // Returns true if bit is set that states that the flags register is updated.
+  inline UpdatesConditionsBit20Interface() {}
+  // Returns true if bit is set that states that the condition bits
+  // APSR is updated.
   static inline bool is_updated(const Instruction i) {
     return i.bit(20);
   }
-  // Returns the flags register if it is used.
-  static inline Register reg_if_updated(const Instruction i) {
-    return is_updated(i) ? kRegisterFlags : kRegisterNone;
+  // Returns the conditions register if it is used.
+  static inline Register conds_if_updated(const Instruction i) {
+    return is_updated(i) ? kConditions : kRegisterNone;
   }
 
  private:
-  NACL_DISALLOW_COPY_AND_ASSIGN(UpdatesFlagsRegisterBit20Interface);
+  NACL_DISALLOW_COPY_AND_ASSIGN(UpdatesConditionsBit20Interface);
 };
 
 // A class decoder is designed to decode a set of instructions that
 // have the same semantics, in terms of what the validator needs. This
 // includes the bit ranges in the instruction that correspond to
 // assigned registers.  as well as whether the instruction is safe to
 // use within the validator.
 //
 // The important property of these class decoders is that the
 // corresponding DecoderState (defined in decoder.h) will inspect the
@@ skipping 20 matching lines @@
   // cannot touch global state, this will not check things that may vary with
   // ABI version.
   //
   // The most positive result this can return is called MAY_BE_SAFE because it
   // is necessary, but not sufficient: the validator has the final say.
   virtual SafetyLevel safety(Instruction i) const = 0;
 
   // Gets the set of registers affected when an instruction executes.  This set
   // is complete, and includes
   //  - explicit destination register(s),
-  //  - changes to flags,
+  //  - changes to condition flags,
   //  - indexed-addressing writeback,
   //  - changes to r15 by branches,
   //  - implicit register results, like branch-with-link.
   //
+  // Note: If you are unsure if an instruction changes condition flags, be
+  // conservative and add it to the set of registers returned by this
+  // function. Failure to do so may cause a potential break in pattern
+  // atomicity, which checks that two instructions run under the same condition.
+  //
   // The default implementation returns a ridiculous bitmask that suggests that
   // all possible side effects will occur -- override if this is not
   // appropriate. :-)
   virtual RegisterList defs(Instruction i) const {
     UNREFERENCED_PARAMETER(i);
     return kRegisterListEverything;
   }
 
   // Gets the set of registers that this instruction defines through immediate
   // indexed addressing writeback -- a subset of the defs() set.
@@ skipping 177 matching lines @@
   inline Unpredictable() : UnsafeClassDecoder(UNPREDICTABLE) {}
   virtual ~Unpredictable() {}
 
  private:
   NACL_DISALLOW_COPY_AND_ASSIGN(Unpredictable);
 };
 
 }  // namespace
 
 #endif  // NATIVE_CLIENT_SRC_TRUSTED_VALIDATOR_ARM_INST_CLASSES_H_