hphp/runtime/base/empty-array.cpp

   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 #include "hphp/runtime/base/empty-array.h"
  18
  19 #include <type_traits>
  20
  21 #include "hphp/util/assertions.h"
  22
  23 #include "hphp/runtime/base/array-data.h"
  24 #include "hphp/runtime/base/array-init.h"
  25 #include "hphp/runtime/base/tv-val.h"
  26 #include "hphp/runtime/base/mixed-array-defs.h"
  27 #include "hphp/runtime/base/mixed-array.h"
  28 #include "hphp/runtime/base/packed-array-defs.h"
  29 #include "hphp/runtime/base/set-array.h"
  30 #include "hphp/runtime/base/tv-mutate.h"
  31 #include "hphp/runtime/base/tv-type.h"
  32 #include "hphp/runtime/base/tv-variant.h"
  33 #include "hphp/runtime/base/type-variant.h"
  34
  35 namespace HPHP {
  36
  37 //////////////////////////////////////////////////////////////////////
  38
  39 std::aligned_storage<sizeof(ArrayData), 16>::type s_theEmptyArray;
  40
  41 struct EmptyArray::Initializer {
  42   Initializer() {
  43     auto const ad   = reinterpret_cast<ArrayData*>(&s_theEmptyArray);
  44     ad->m_sizeAndPos = 0;
  45     ad->initHeader(HeaderKind::Empty, StaticValue);
  46   }
  47 };
  48 EmptyArray::Initializer EmptyArray::s_initializer;
  49
  50 //////////////////////////////////////////////////////////////////////
  51
  52 void EmptyArray::Release(ArrayData*) {
  53   always_assert(!"never try to free the empty array");
  54 }
  55
  56 Cell EmptyArray::NvGetKey(const ArrayData*, ssize_t /*pos*/) {
  57   // We have no valid positions---no one should call this function.
  58   not_reached();
  59 }
  60
  61 size_t EmptyArray::Vsize(const ArrayData*) { not_reached(); }
  62
  63 tv_rval EmptyArray::GetValueRef(const ArrayData* /*ad*/, ssize_t /*pos*/) {
  64   // We have no valid positions---no one should call this function.
  65   not_reached();
  66 }
  67
  68 // EmptyArray::IterAdvance() is reachable; see ArrayData::next() for details
  69 ssize_t EmptyArray::IterAdvance(const ArrayData*, ssize_t /*prev*/) {
  70   return 0;
  71 }
  72
  73 // EmptyArray::IterRewind() is NOT reachable; see ArrayData::prev() for details
  74 ssize_t EmptyArray::IterRewind(const ArrayData*, ssize_t /*prev*/) {
  75   not_reached();
  76 }
  77
  78 // We're always already a static array.
  79 void EmptyArray::OnSetEvalScalar(ArrayData*) { not_reached(); }
  80 ArrayData* EmptyArray::CopyStatic(const ArrayData* /*ad*/) {
  81   not_reached();
  82 }
  83
  84 //////////////////////////////////////////////////////////////////////
  85
  86 NEVER_INLINE
  87 ArrayData* EmptyArray::Copy(const ArrayData*) { return staticEmptyArray(); }
  88
  89 //////////////////////////////////////////////////////////////////////
  90
  91 /*
  92  * Note: if you try to tail-call these helper routines, gcc will
  93  * unfortunately still generate functions with frames and makes a
  94  * call instead of a jump.  It's because of std::pair (and is still
  95  * the case if you return a custom struct).
  96  *
  97  * For now we're leaving this, because it's essentially free for these
  98  * routines to leave the lval pointer in the second return register,
  99  * and it seems questionable to clone the whole function just to avoid
 100  * the frame creation in these callers.  (It works to reinterpret_cast
 101  * these functions to one that returns ArrayData* instead of a pair in
 102  * the cases we don't need the second value, but this seems a tad too
 103  * sketchy for probably-unmeasurable benefits.  I'll admit I didn't
 104  * try to measure it though... ;)
 105  */
 106
 107 /*
 108  * Helper for empty array -> packed transitions.  Creates an array
 109  * with one element.  The element is transferred into the array (should
 110  * already be incref'd).
 111  */
 112 ALWAYS_INLINE
 113 arr_lval EmptyArray::MakePackedInl(TypedValue tv) {
 114   auto const ad = static_cast<ArrayData*>(
 115     tl_heap->objMallocIndex(PackedArray::SmallSizeIndex)
 116   );
 117   ad->initHeader_16(
 118     HeaderKind::Packed,
 119     OneReference,
 120     PackedArray::packSizeIndexAndAuxBits(
 121       PackedArray::SmallSizeIndex,
 122       ArrayData::kNotDVArray
 123     )
 124   );
 125   ad->m_sizeAndPos = 1; // size=1, pos=0
 126
 127   auto elem = PackedArray::LvalUncheckedInt(ad, 0);
 128   tvCopy(tv, elem);
 129
 130   assertx(ad->kind() == ArrayData::kPackedKind);
 131   assertx(ad->dvArray() == ArrayData::kNotDVArray);
 132   assertx(ad->m_size == 1);
 133   assertx(ad->m_pos == 0);
 134   assertx(ad->hasExactlyOneRef());
 135   assertx(PackedArray::checkInvariants(ad));
 136   return arr_lval { ad, elem };
 137 }
 138
 139 NEVER_INLINE
 140 arr_lval EmptyArray::MakePacked(TypedValue tv) {
 141   return MakePackedInl(tv);
 142 }
 143
 144 /*
 145  * Helper for creating a single-element mixed array with a string key.
 146  *
 147  * Note: the key is not already incref'd, but the value must be.
 148  */
 149 NEVER_INLINE
 150 arr_lval EmptyArray::MakeMixed(StringData* key, TypedValue val) {
 151   auto const ad = MixedArray::reqAlloc(MixedArray::SmallScale);
 152   MixedArray::InitSmall(ad, 1/*size*/, 0/*nextIntKey*/);
 153   auto const data = ad->data();
 154   auto const hash = reinterpret_cast<int32_t*>(data + MixedArray::SmallSize);
 155   auto const khash = key->hash();
 156   auto const mask = MixedArray::SmallMask;
 157   hash[khash & mask] = 0;
 158   data[0].setStrKey(key, khash);
 159
 160   auto& elem  = data[0].data;
 161   elem.m_data = val.m_data;
 162   elem.m_type = val.m_type;
 163
 164   assertx(ad->m_size == 1);
 165   assertx(ad->m_pos == 0);
 166   assertx(ad->m_scale == MixedArray::SmallScale);
 167   assertx(ad->kind() == ArrayData::kMixedKind);
 168   assertx(ad->hasExactlyOneRef());
 169   assertx(ad->m_used == 1);
 170   assertx(ad->checkInvariants());
 171   return arr_lval { ad, &elem };
 172 }
 173
 174 /*
 175  * Creating a single-element mixed array with a integer key.  The
 176  * value is already incref'd.
 177  */
 178 arr_lval EmptyArray::MakeMixed(int64_t key, TypedValue val) {
 179   auto const ad = MixedArray::reqAlloc(MixedArray::SmallScale);
 180   MixedArray::InitSmall(ad, 1/*size*/, (key >= 0) ? key + uint64_t{1} : 0);
 181   auto const data = ad->data();
 182   auto const hash = reinterpret_cast<int32_t*>(data + MixedArray::SmallSize);
 183
 184   auto const mask = MixedArray::SmallMask;
 185   auto h = hash_int64(key);
 186   hash[h & mask] = 0;
 187   data[0].setIntKey(key, h);
 188
 189   auto& elem  = data[0].data;
 190   elem.m_data = val.m_data;
 191   elem.m_type = val.m_type;
 192
 193   assertx(ad->kind() == ArrayData::kMixedKind);
 194   assertx(ad->m_size == 1);
 195   assertx(ad->m_pos == 0);
 196   assertx(ad->hasExactlyOneRef());
 197   assertx(ad->m_scale == MixedArray::SmallScale);
 198   assertx(ad->m_used == 1);
 199   assertx(ad->checkInvariants());
 200   return arr_lval { ad, &elem };
 201 }
 202
 203 //////////////////////////////////////////////////////////////////////
 204
 205 template<bool warn> ALWAYS_INLINE
 206 arr_lval EmptyArray::LvalIntImpl(ArrayData*, int64_t k, bool) {
 207   if (warn && checkHACFalseyPromote()) {
 208     raise_hac_falsey_promote_notice("Lval on missing array element");
 209   }
 210   return k == 0 ? EmptyArray::MakePacked(make_tv<KindOfNull>())
 211                 : EmptyArray::MakeMixed(k, make_tv<KindOfNull>());
 212 }
 213
 214 template<bool warn> ALWAYS_INLINE
 215 arr_lval EmptyArray::LvalStrImpl(ArrayData*, StringData* k, bool) {
 216   if (warn && checkHACFalseyPromote()) {
 217     raise_hac_falsey_promote_notice("Lval on missing array element");
 218   }
 219   return EmptyArray::MakeMixed(k, make_tv<KindOfNull>());
 220 }
 221
 222 ArrayData* EmptyArray::SetInt(ArrayData*, int64_t k, Cell v) {
 223   // TODO(#3888164): we should make it so we don't need KindOfUninit checks
 224   if (v.m_type == KindOfUninit) v.m_type = KindOfNull;
 225   tvIncRefGen(v);
 226   auto const lval = k == 0 ? EmptyArray::MakePacked(v)
 227                            : EmptyArray::MakeMixed(k, v);
 228   return lval.arr;
 229 }
 230
 231 ArrayData*
 232 EmptyArray::SetStr(ArrayData*, StringData* k, Cell v) {
 233   tvIncRefGen(v);
 234   // TODO(#3888164): we should make it so we don't need KindOfUninit checks
 235   if (v.m_type == KindOfUninit) v.m_type = KindOfNull;
 236   return EmptyArray::MakeMixed(k, v).arr;
 237 }
 238
 239 ArrayData* EmptyArray::SetWithRefInt(ArrayData* ad, int64_t k, TypedValue v) {
 240   if (checkHACRefBind() && tvIsReferenced(v)) {
 241     raiseHackArrCompatRefBind(k);
 242   }
 243   auto const lval = LvalIntImpl<false>(ad, k, ad->cowCheck());
 244   tvSetWithRef(v, lval);
 245   return lval.arr;
 246 }
 247
 248 ArrayData* EmptyArray::SetWithRefStr(ArrayData* ad, StringData* k,
 249                                      TypedValue v) {
 250   if (checkHACRefBind() && tvIsReferenced(v)) {
 251     raiseHackArrCompatRefBind(k);
 252   }
 253   auto const lval = LvalStrImpl<false>(ad, k, ad->cowCheck());
 254   tvSetWithRef(v, lval);
 255   return lval.arr;
 256 }
 257
 258 ArrayData* EmptyArray::RemoveInt(ArrayData* ad, int64_t) {
 259   return ad;
 260 }
 261
 262 ArrayData* EmptyArray::RemoveStr(ArrayData* ad, const StringData*) {
 263   return ad;
 264 }
 265
 266 arr_lval EmptyArray::LvalInt(ArrayData* ad, int64_t k, bool copy) {
 267   return LvalIntImpl<true>(ad, k, copy);
 268 }
 269
 270 arr_lval EmptyArray::LvalIntRef(ArrayData* ad, int64_t k, bool copy) {
 271   if (checkHACRefBind()) raiseHackArrCompatRefBind(k);
 272   return LvalInt(ad, k, copy);
 273 }
 274
 275 arr_lval EmptyArray::LvalStr(ArrayData* ad, StringData* k, bool copy) {
 276   return LvalStrImpl<true>(ad, k, copy);
 277 }
 278
 279 arr_lval EmptyArray::LvalStrRef(ArrayData* ad, StringData* k, bool copy) {
 280   if (checkHACRefBind()) raiseHackArrCompatRefBind(k);
 281   return LvalStr(ad, k, copy);
 282 }
 283
 284 arr_lval EmptyArray::LvalNew(ArrayData*, bool) {
 285   if (checkHACFalseyPromote()) {
 286     raise_hac_falsey_promote_notice("Lval on missing array element");
 287   }
 288   return EmptyArray::MakePacked(make_tv<KindOfNull>());
 289 }
 290
 291 arr_lval EmptyArray::LvalNewRef(ArrayData* ad, bool copy) {
 292   if (checkHACRefBind()) raiseHackArrCompatRefNew();
 293   return LvalNew(ad, copy);
 294 }
 295
 296 ArrayData* EmptyArray::Append(ArrayData*, Cell v) {
 297   tvIncRefGen(v);
 298   return EmptyArray::MakePackedInl(v).arr;
 299 }
 300
 301 ArrayData* EmptyArray::AppendWithRef(ArrayData*, TypedValue v) {
 302   if (checkHACRefBind() && tvIsReferenced(v)) {
 303     raiseHackArrCompatRefNew();
 304   }
 305   auto tv = make_tv<KindOfNull>();
 306   tvAsVariant(&tv).setWithRef(v);
 307   return EmptyArray::MakePacked(tv).arr;
 308 }
 309
 310 //////////////////////////////////////////////////////////////////////
 311
 312 ArrayData* EmptyArray::PlusEq(ArrayData*, const ArrayData* elems) {
 313   if (!elems->isPHPArray()) throwInvalidAdditionException(elems);
 314   elems->incRefCount();
 315   return const_cast<ArrayData*>(elems);
 316 }
 317
 318 ArrayData* EmptyArray::Merge(ArrayData*, const ArrayData* elems) {
 319   if (elems->isNotDVArray()) {
 320     // Packed arrays don't need renumbering, so don't make a copy.
 321     if (elems->isPacked()) {
 322       elems->incRefCount();
 323       return const_cast<ArrayData*>(elems);
 324     }
 325     // Fast path the common case that elems is mixed.
 326     if (elems->isMixed()) {
 327       auto const copy = MixedArray::Copy(elems);
 328       assertx(copy != elems);
 329       MixedArray::Renumber(copy);
 330       return copy;
 331     }
 332   }
 333   auto copy = const_cast<ArrayData*>(elems)->toPHPArray(true);
 334   copy = copy == elems ? elems->copy() : copy;
 335   assertx(copy != elems);
 336   copy->renumber();
 337   return copy;
 338 }
 339
 340 ArrayData* EmptyArray::PopOrDequeue(ArrayData* ad, Variant& value) {
 341   value = uninit_null();
 342   return ad;
 343 }
 344
 345 ArrayData* EmptyArray::Prepend(ArrayData*, Cell v) {
 346   tvIncRefGen(v);
 347   return EmptyArray::MakePacked(v).arr;
 348 }
 349
 350 ArrayData* EmptyArray::ToDict(ArrayData*, bool) {
 351   return staticEmptyDictArray();
 352 }
 353
 354 ArrayData* EmptyArray::ToShape(ArrayData*, bool) {
 355   return staticEmptyShapeArray();
 356 }
 357
 358 ArrayData* EmptyArray::ToVec(ArrayData*, bool) {
 359   return staticEmptyVecArray();
 360 }
 361
 362 ArrayData* EmptyArray::ToKeyset(ArrayData*, bool) {
 363   return staticEmptyKeysetArray();
 364 }
 365
 366 //////////////////////////////////////////////////////////////////////
 367
 368 }