1    :  // Copyright 2014 Google Inc. All Rights Reserved.
   2    :  //
   3    :  // Licensed under the Apache License, Version 2.0 (the "License");
   4    :  // you may not use this file except in compliance with the License.
   5    :  // You may obtain a copy of the License at
   6    :  //
   7    :  //     http://www.apache.org/licenses/LICENSE-2.0
   8    :  //
   9    :  // Unless required by applicable law or agreed to in writing, software
  10    :  // distributed under the License is distributed on an "AS IS" BASIS,
  11    :  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12    :  // See the License for the specific language governing permissions and
  13    :  // limitations under the License.
  14    :  //
  15    :  // This file declares implementation classes to generate assembly code.
  16    :  // The API to the assembler is intentionally very close to the API exposed
  17    :  // by the V8 assembler (see src/ia32/assembler-ia32.* in V8 repository).
  18    :  
  19    :  #ifndef SYZYGY_ASSM_VALUE_BASE_H_
  20    :  #define SYZYGY_ASSM_VALUE_BASE_H_
  21    :  
  22    :  #include "syzygy/assm/register.h"
  23    :  
  24    :  namespace assm {
  25    :  
  26    :  // We use the same enum for value sizes.
  27    :  typedef RegisterSize ValueSize;
  28    :  
  29    :  // An instance of this class is an explicit value, which is either
  30    :  // an immediate or a displacement.
  31    :  template <class ReferenceType, class SubclassType>
  32    :  class ValueBase {
  33    :   public:
  34    :    ValueBase();
  35    :    ValueBase(uint32 value, ValueSize size);
  36    :    ValueBase(uint32 value, ValueSize size, ReferenceType imm_ref);
  37    :  
  38    :    // @name Accessors.
  39    :    // @{
  40  E :    uint32 value() const { return value_; }
  41  E :    const ReferenceType& reference() const { return reference_; }
  42  E :    ValueSize size() const { return size_; }
  43    :    // @}
  44    :  
  45    :    // Comparison operator.
  46    :    bool operator==(const ValueBase& rhs) const;
  47    :  
  48    :   private:
  49    :    uint32 value_;
  50    :    ReferenceType reference_;
  51    :    ValueSize size_;
  52    :  };
  53    :  
  54    :  template <class ReferenceType>
  55    :  class ImmediateBase
  56    :      : public ValueBase<ReferenceType, ImmediateBase<ReferenceType>> {
  57    :   public:
  58    :    typedef ValueBase<ReferenceType, ImmediateBase<ReferenceType>> Super;
  59    :  
  60  E :    ImmediateBase() {
  61  E :    }
  62  E :    ImmediateBase(uint32 value, ValueSize size) : Super(value, size) {
  63  E :    }
  64  E :    ImmediateBase(uint32 value, ValueSize size, ReferenceType imm_ref)
  65    :        : Super(value, size, imm_ref) {
  66  E :    }
  67    :  };
  68    :  
  69    :  template <class ReferenceType>
  70    :  class DisplacementBase
  71    :      : public ValueBase<ReferenceType, DisplacementBase<ReferenceType>> {
  72    :   public:
  73    :    typedef ValueBase<ReferenceType, DisplacementBase<ReferenceType>> Super;
  74    :  
  75  E :    DisplacementBase() {
  76  E :    }
  77  E :    DisplacementBase(uint32 value, ValueSize size) : Super(value, size) {
  78  E :    }
  79  E :    DisplacementBase(uint32 value, ValueSize size, ReferenceType imm_ref)
  80    :        : Super(value, size, imm_ref) {
  81  E :    }
  82    :  };
  83    :  
  84    :  template <class ReferenceType, class SubclassType>
  85    :  ValueBase<ReferenceType, SubclassType>::ValueBase()
  86  E :      : value_(0), reference_(), size_(kSizeNone) {
  87  E :  }
  88    :  
  89    :  template <class ReferenceType, class SubclassType>
  90    :  ValueBase<ReferenceType, SubclassType>::ValueBase(uint32 value, ValueSize size)
  91  E :      : value_(value), reference_(), size_(size) {
  92  E :  }
  93    :  
  94    :  template <class ReferenceType, class SubclassType>
  95    :  ValueBase<ReferenceType, SubclassType>::ValueBase(
  96    :      uint32 value, ValueSize size, ReferenceType value_ref)
  97  E :      : value_(value), reference_(value_ref), size_(size) {
  98    :    // We can't have a 16-bit value *and* a reference, as there are no
  99    :    // addressing modes that accept 16-bit input.
 100    :  
 101  E :    DCHECK(!details::IsValidReference(value_ref) || size != kSize16Bit);
 102  E :  }
 103    :  
 104    :  template <class ReferenceType, class SubclassType>
 105    :  bool ValueBase<ReferenceType, SubclassType>::operator==(
 106  E :      const ValueBase& rhs) const {
 107    :    return value_ == rhs.value_ &&
 108    :        reference_ == rhs.reference_ &&
 109  E :        size_ == rhs.size_;
 110  E :  }
 111    :  
 112    :  }  // namespace assm
 113    :  
 114    :  #endif  // SYZYGY_ASSM_VALUE_BASE_H_