hphp/runtime/vm/coeffects.h

   1 /*
   2    +----------------------------------------------------------------------+
   3    | HipHop for PHP                                                       |
   4    +----------------------------------------------------------------------+
   5    | Copyright (c) 2010-present Facebook, Inc. (http://www.facebook.com)  |
   6    +----------------------------------------------------------------------+
   7    | This source file is subject to version 3.01 of the PHP license,      |
   8    | that is bundled with this package in the file LICENSE, and is        |
   9    | available through the world-wide-web at the following url:           |
  10    | http://www.php.net/license/3_01.txt                                  |
  11    | If you did not receive a copy of the PHP license and are unable to   |
  12    | obtain it through the world-wide-web, please send a note to          |
  13    | license@php.net so we can mail you a copy immediately.               |
  14    +----------------------------------------------------------------------+
  15 */
  16
  17 #pragma once
  18
  19 #include "hphp/runtime/vm/class.h"
  20
  21 #include <folly/Optional.h>
  22
  23 namespace HPHP {
  24 ///////////////////////////////////////////////////////////////////////////////
  25 namespace jit {
  26 struct SSATmp;
  27 namespace irgen {
  28 struct IRGS;
  29 }
  30 }
  31 ///////////////////////////////////////////////////////////////////////////////
  32 struct RuntimeCoeffects {
  33   using storage_t = uint16_t;
  34
  35   static RuntimeCoeffects fromValue(uint16_t value) {
  36     return RuntimeCoeffects{value};
  37   }
  38
  39   static RuntimeCoeffects none() {
  40     return RuntimeCoeffects::fromValue(0);
  41   }
  42
  43   static RuntimeCoeffects full() {
  44     return RuntimeCoeffects::fromValue(std::numeric_limits<storage_t>::max());
  45   }
  46
  47   uint16_t value() const { return m_data; }
  48
  49   const std::string toString() const;
  50
  51   // Checks whether provided coeffects in `this` can call
  52   // required coeffects in `o`
  53   bool canCall(const RuntimeCoeffects o) const {
  54     // a & b == a
  55     // a & ~b == 0
  56     return (m_data & (~o.m_data)) == 0;
  57   }
  58
  59   bool canCallWithWarning(const RuntimeCoeffects) const;
  60
  61   // This operator is equivalent to | of [coeffectA | coeffectB]
  62   RuntimeCoeffects& operator&=(const RuntimeCoeffects);
  63
  64 private:
  65   explicit RuntimeCoeffects(uint16_t data) : m_data(data) {}
  66   storage_t m_data;
  67 };
  68
  69 struct StaticCoeffects {
  70   using storage_t = RuntimeCoeffects::storage_t;
  71
  72   const folly::Optional<std::string> toString() const;
  73
  74   RuntimeCoeffects toAmbient() const;
  75   RuntimeCoeffects toRequired() const;
  76
  77   // Returns the corresponding shallow bits for coeffects that are local
  78   RuntimeCoeffects toShallowWithLocals() const;
  79
  80   static StaticCoeffects fromValue(uint16_t value) {
  81     return StaticCoeffects{value};
  82   }
  83
  84   uint16_t value() const { return m_data; }
  85
  86   static StaticCoeffects none() {
  87     return StaticCoeffects::fromValue(0);
  88   }
  89
  90   // This operator is equivalent to & of [coeffectA & coeffectB]
  91   StaticCoeffects& operator|=(const StaticCoeffects);
  92
  93   template<class SerDe>
  94   void serde(SerDe& sd) {
  95     sd(m_data);
  96   }
  97
  98 private:
  99   // Returns the local bits
 100   storage_t locals() const;
 101
 102 private:
 103   explicit StaticCoeffects(uint16_t data) : m_data(data) {}
 104   storage_t m_data;
 105 };
 106
 107 static_assert(sizeof(StaticCoeffects) == sizeof(uint16_t), "");
 108 static_assert(sizeof(StaticCoeffects) == sizeof(RuntimeCoeffects), "");
 109
 110 ///////////////////////////////////////////////////////////////////////////////
 111
 112 struct CoeffectRule final {
 113   struct FunParam {};
 114   struct CCParam {};
 115   struct CCThis {};
 116
 117   CoeffectRule() = default;
 118
 119   /////////////////////////////////////////////////////////////////////////////
 120   // Native coeffect rules ////////////////////////////////////////////////////
 121
 122   CoeffectRule(FunParam, uint32_t index)
 123     : m_type(Type::FunParam)
 124     , m_index(index)
 125   {}
 126
 127   CoeffectRule(CCParam, uint32_t index, const StringData* ctx_name)
 128     : m_type(Type::CCParam)
 129     , m_index(index)
 130     , m_name(ctx_name)
 131   { assertx(ctx_name); }
 132
 133   CoeffectRule(CCThis, const StringData* ctx_name)
 134     : m_type(Type::CCThis)
 135     , m_name(ctx_name)
 136   { assertx(ctx_name); }
 137
 138   RuntimeCoeffects emit(const Func*, uint32_t, void*) const;
 139   jit::SSATmp* emitJit(jit::irgen::IRGS&, const Func*,
 140                        uint32_t, jit::SSATmp*) const;
 141
 142   folly::Optional<std::string> toString(const Func*) const;
 143   std::string getDirectiveString() const;
 144
 145   template<class SerDe>
 146   void serde(SerDe&);
 147
 148 private:
 149   enum class Type {
 150     Invalid = 0,
 151
 152     FunParam,
 153     CCParam,
 154     CCThis,
 155   };
 156
 157   Type m_type{Type::Invalid};
 158   uint32_t m_index{0};
 159   LowPtr<const StringData> m_name{nullptr};
 160 };
 161
 162 ///////////////////////////////////////////////////////////////////////////////
 163 }