src/v8/src/compiler/machine-type.h

   1 // Copyright 2014 the V8 project authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef V8_COMPILER_MACHINE_TYPE_H_
   6 #define V8_COMPILER_MACHINE_TYPE_H_
   7
   8 #include "src/base/bits.h"
   9 #include "src/globals.h"
  10 #include "src/zone.h"
  11
  12 namespace v8 {
  13 namespace internal {
  14
  15 class OStream;
  16
  17 namespace compiler {
  18
  19 // Machine-level types and representations.
  20 // TODO(titzer): Use the real type system instead of MachineType.
  21 enum MachineType {
  22   // Representations.
  23   kRepBit = 1 << 0,
  24   kRepWord8 = 1 << 1,
  25   kRepWord16 = 1 << 2,
  26   kRepWord32 = 1 << 3,
  27   kRepWord64 = 1 << 4,
  28   kRepFloat32 = 1 << 5,
  29   kRepFloat64 = 1 << 6,
  30   kRepTagged = 1 << 7,
  31
  32   // Types.
  33   kTypeBool = 1 << 8,
  34   kTypeInt32 = 1 << 9,
  35   kTypeUint32 = 1 << 10,
  36   kTypeInt64 = 1 << 11,
  37   kTypeUint64 = 1 << 12,
  38   kTypeNumber = 1 << 13,
  39   kTypeAny = 1 << 14,
  40
  41   // Machine types.
  42   kMachNone = 0,
  43   kMachFloat32 = kRepFloat32 | kTypeNumber,
  44   kMachFloat64 = kRepFloat64 | kTypeNumber,
  45   kMachInt8 = kRepWord8 | kTypeInt32,
  46   kMachUint8 = kRepWord8 | kTypeUint32,
  47   kMachInt16 = kRepWord16 | kTypeInt32,
  48   kMachUint16 = kRepWord16 | kTypeUint32,
  49   kMachInt32 = kRepWord32 | kTypeInt32,
  50   kMachUint32 = kRepWord32 | kTypeUint32,
  51   kMachInt64 = kRepWord64 | kTypeInt64,
  52   kMachUint64 = kRepWord64 | kTypeUint64,
  53   kMachPtr = (kPointerSize == 4) ? kRepWord32 : kRepWord64,
  54   kMachAnyTagged = kRepTagged | kTypeAny
  55 };
  56
  57 OStream& operator<<(OStream& os, const MachineType& type);
  58
  59 typedef uint16_t MachineTypeUnion;
  60
  61 // Globally useful machine types and constants.
  62 const MachineTypeUnion kRepMask = kRepBit | kRepWord8 | kRepWord16 |
  63                                   kRepWord32 | kRepWord64 | kRepFloat32 |
  64                                   kRepFloat64 | kRepTagged;
  65 const MachineTypeUnion kTypeMask = kTypeBool | kTypeInt32 | kTypeUint32 |
  66                                    kTypeInt64 | kTypeUint64 | kTypeNumber |
  67                                    kTypeAny;
  68
  69 // Gets only the type of the given type.
  70 inline MachineType TypeOf(MachineType machine_type) {
  71   int result = machine_type & kTypeMask;
  72   return static_cast<MachineType>(result);
  73 }
  74
  75 // Gets only the representation of the given type.
  76 inline MachineType RepresentationOf(MachineType machine_type) {
  77   int result = machine_type & kRepMask;
  78   CHECK(base::bits::IsPowerOfTwo32(result));
  79   return static_cast<MachineType>(result);
  80 }
  81
  82 // Gets the element size in bytes of the machine type.
  83 inline int ElementSizeOf(MachineType machine_type) {
  84   switch (RepresentationOf(machine_type)) {
  85     case kRepBit:
  86     case kRepWord8:
  87       return 1;
  88     case kRepWord16:
  89       return 2;
  90     case kRepWord32:
  91     case kRepFloat32:
  92       return 4;
  93     case kRepWord64:
  94     case kRepFloat64:
  95       return 8;
  96     case kRepTagged:
  97       return kPointerSize;
  98     default:
  99       UNREACHABLE();
 100       return kPointerSize;
 101   }
 102 }
 103
 104 // Describes the inputs and outputs of a function or call.
 105 template <typename T>
 106 class Signature : public ZoneObject {
 107  public:
 108   Signature(size_t return_count, size_t parameter_count, T* reps)
 109       : return_count_(return_count),
 110         parameter_count_(parameter_count),
 111         reps_(reps) {}
 112
 113   size_t return_count() const { return return_count_; }
 114   size_t parameter_count() const { return parameter_count_; }
 115
 116   T GetParam(size_t index) const {
 117     DCHECK(index < parameter_count_);
 118     return reps_[return_count_ + index];
 119   }
 120
 121   T GetReturn(size_t index = 0) const {
 122     DCHECK(index < return_count_);
 123     return reps_[index];
 124   }
 125
 126   // For incrementally building signatures.
 127   class Builder {
 128    public:
 129     Builder(Zone* zone, size_t return_count, size_t parameter_count)
 130         : return_count_(return_count),
 131           parameter_count_(parameter_count),
 132           zone_(zone),
 133           rcursor_(0),
 134           pcursor_(0),
 135           buffer_(zone->NewArray<T>(
 136               static_cast<int>(return_count + parameter_count))) {}
 137
 138     const size_t return_count_;
 139     const size_t parameter_count_;
 140
 141     void AddReturn(T val) {
 142       DCHECK(rcursor_ < return_count_);
 143       buffer_[rcursor_++] = val;
 144     }
 145     void AddParam(T val) {
 146       DCHECK(pcursor_ < parameter_count_);
 147       buffer_[return_count_ + pcursor_++] = val;
 148     }
 149     Signature<T>* Build() {
 150       DCHECK(rcursor_ == return_count_);
 151       DCHECK(pcursor_ == parameter_count_);
 152       return new (zone_) Signature<T>(return_count_, parameter_count_, buffer_);
 153     }
 154
 155    private:
 156     Zone* zone_;
 157     size_t rcursor_;
 158     size_t pcursor_;
 159     T* buffer_;
 160   };
 161
 162  protected:
 163   size_t return_count_;
 164   size_t parameter_count_;
 165   T* reps_;
 166 };
 167
 168 typedef Signature<MachineType> MachineSignature;
 169 }  // namespace compiler
 170 }  // namespace internal
 171 }  // namespace v8
 172
 173 #endif  // V8_COMPILER_MACHINE_TYPE_H_