Merges ARM load/store type enums into one enum.

runtime/vm/assembler_arm.h

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #ifndef VM_ASSEMBLER_ARM_H_
 #define VM_ASSEMBLER_ARM_H_
 
 #ifndef VM_ASSEMBLER_H_
 #error Do not include assembler_arm.h directly; use assembler.h instead.
 #endif
@@ skipping 158 matching lines @@
   }
 
   uint32_t type_;  // Encodes the type field (bits 27-25) in the instruction.
   uint32_t encoding_;
 
   friend class Assembler;
   friend class Address;
 };
 
 
-enum LoadOperandType {
-  kLoadSignedByte,
-  kLoadUnsignedByte,
-  kLoadSignedHalfword,
-  kLoadUnsignedHalfword,
-  kLoadWord,
-  kLoadWordPair,
-  kLoadSWord,
-  kLoadDWord
-};
-
-
-enum StoreOperandType {
-  kStoreByte,
-  kStoreHalfword,
-  kStoreWord,
-  kStoreWordPair,
-  kStoreSWord,
-  kStoreDWord
+enum OperandSize {
+  kByte,
+  kUnsignedByte,
+  kHalfword,
+  kUnsignedHalfword,
+  kWord,
+  kUnsignedWord,
+  kWordPair,
+  kSWord,
+  kDWord,
 };
 
 
 // Load/store multiple addressing mode.
 enum BlockAddressMode {
   // bit encoding P U W
   DA           = (0|0|0) << 21,  // decrement after
   IA           = (0|4|0) << 21,  // increment after
   DB           = (8|0|0) << 21,  // decrement before
   IB           = (8|4|0) << 21,  // increment before
@@ skipping 53 matching lines @@
     } else {
       kind_ = ScaledIndexRegister;
     }
     encoding_ = so.encoding() | am | (static_cast<uint32_t>(rn) << kRnShift);
   }
 
   bool Equals(const Address& other) {
     return (encoding_ == other.encoding_) && (kind_ == other.kind_);
   }
 
-  static bool CanHoldLoadOffset(LoadOperandType type,
+  static bool CanHoldLoadOffset(OperandSize type,
                                 int32_t offset,
                                 int32_t* offset_mask);
-  static bool CanHoldStoreOffset(StoreOperandType type,
+  static bool CanHoldStoreOffset(OperandSize type,
                                  int32_t offset,
                                  int32_t* offset_mask);
 
  private:
   uint32_t encoding() const { return encoding_; }
 
   // Encoding for addressing mode 3.
   uint32_t encoding3() const;
 
   // Encoding for vfp load/store addressing.
@@ skipping 187 matching lines @@
   void vstms(BlockAddressMode am, Register base,
              SRegister first, SRegister last, Condition cond = AL);
 
   void vldmd(BlockAddressMode am, Register base,
              DRegister first, DRegister last, Condition cond = AL);
   void vstmd(BlockAddressMode am, Register base,
              DRegister first, DRegister last, Condition cond = AL);
 
   void vadds(SRegister sd, SRegister sn, SRegister sm, Condition cond = AL);
   void vaddd(DRegister dd, DRegister dn, DRegister dm, Condition cond = AL);
-  void vaddqi(int sz, QRegister qd, QRegister qn, QRegister qm);
+  void vaddqi(OperandSize sz, QRegister qd, QRegister qn, QRegister qm);
   void vaddqs(QRegister qd, QRegister qn, QRegister qm);
   void vsubs(SRegister sd, SRegister sn, SRegister sm, Condition cond = AL);
   void vsubd(DRegister dd, DRegister dn, DRegister dm, Condition cond = AL);
-  void vsubqi(int sz, QRegister qd, QRegister qn, QRegister qm);
+  void vsubqi(OperandSize sz, QRegister qd, QRegister qn, QRegister qm);
   void vsubqs(QRegister qd, QRegister qn, QRegister qm);
   void vmuls(SRegister sd, SRegister sn, SRegister sm, Condition cond = AL);
   void vmuld(DRegister dd, DRegister dn, DRegister dm, Condition cond = AL);
-  void vmulqi(int sz, QRegister qd, QRegister qn, QRegister qm);
+  void vmulqi(OperandSize sz, QRegister qd, QRegister qn, QRegister qm);
   void vmulqs(QRegister qd, QRegister qn, QRegister qm);
   void vmlas(SRegister sd, SRegister sn, SRegister sm, Condition cond = AL);
   void vmlad(DRegister dd, DRegister dn, DRegister dm, Condition cond = AL);
   void vmlss(SRegister sd, SRegister sn, SRegister sm, Condition cond = AL);
   void vmlsd(DRegister dd, DRegister dn, DRegister dm, Condition cond = AL);
   void vdivs(SRegister sd, SRegister sn, SRegister sm, Condition cond = AL);
   void vdivd(DRegister dd, DRegister dn, DRegister dm, Condition cond = AL);
 
   void vabss(SRegister sd, SRegister sm, Condition cond = AL);
   void vabsd(DRegister dd, DRegister dm, Condition cond = AL);
@@ skipping 91 matching lines @@
   void StoreIntoObjectNoBarrier(Register object,
                                 const Address& dest,
                                 const Object& value);
 
   void LoadClassId(Register result, Register object);
   void LoadClassById(Register result, Register class_id);
   void LoadClass(Register result, Register object, Register scratch);
   void CompareClassId(Register object, intptr_t class_id, Register scratch);
 
   void LoadWordFromPoolOffset(Register rd, int32_t offset, Condition cond = AL);
-  void LoadFromOffset(LoadOperandType type,
+  void LoadFromOffset(OperandSize type,
                       Register reg,
                       Register base,
                       int32_t offset,
                       Condition cond = AL);
-  void StoreToOffset(StoreOperandType type,
+  void StoreToOffset(OperandSize type,
                      Register reg,
                      Register base,
                      int32_t offset,
                      Condition cond = AL);
   void LoadSFromOffset(SRegister reg,
                        Register base,
                        int32_t offset,
                        Condition cond = AL);
   void StoreSToOffset(SRegister reg,
                       Register base,
@@ skipping 188 matching lines @@
   void EmitVFPsd(Condition cond,
                  int32_t opcode,
                  SRegister sd,
                  DRegister dm);
 
   void EmitVFPds(Condition cond,
                  int32_t opcode,
                  DRegister dd,
                  SRegister sm);
 
-  void EmitSIMDqqq(int32_t opcode, int sz,
+  void EmitSIMDqqq(int32_t opcode, OperandSize sz,
                    QRegister qd, QRegister qn, QRegister qm);
 
   void EmitBranch(Condition cond, Label* label, bool link);
   static int32_t EncodeBranchOffset(int32_t offset, int32_t inst);
   static int DecodeBranchOffset(int32_t inst);
   int32_t EncodeTstOffset(int32_t offset, int32_t inst);
   int DecodeTstOffset(int32_t inst);
 
   void StoreIntoObjectFilter(Register object, Register value, Label* no_update);
 
   // Shorter filtering sequence that assumes that value is not a smi.
   void StoreIntoObjectFilterNoSmi(Register object,
                                   Register value,
                                   Label* no_update);
 
   DISALLOW_ALLOCATION();
   DISALLOW_COPY_AND_ASSIGN(Assembler);
 };
 
 }  // namespace dart
 
 #endif  // VM_ASSEMBLER_ARM_H_