void cgInitObjProps(IRLS& env, const IRInstruction* inst) {
auto const cls = inst->extra<InitObjProps>()->cls;
auto const obj = srcLoc(env, inst, 0).reg();
auto& v = vmain(env);
// Set the attributes, if any.
auto const odAttrs = cls->getODAttrs();
if (odAttrs) {
static_assert(sizeof(ObjectData::Attribute) == 2,
"Codegen expects 2-byte ObjectData attributes");
assertx(!(odAttrs & 0xffff0000));
v << orwim{odAttrs, obj[ObjectData::attributeOff()], v.makeReg()};
}
// Initialize the properties.
auto const nprops = cls->numDeclProperties();
if (nprops > 0) {
if (cls->pinitVec().size() == 0) {
// If the Class has no 86pinit property-initializer functions, we can
// just copy the initial values from a data member on the Class.
implInitObjPropsFast(v, env, inst, obj, cls, nprops);
} else {
// Load the Class's propInitVec from the target cache. We know it's
// already been initialized as a pre-condition on this op.
auto const propHandle = cls->propHandle();
assertx(rds::isNormalHandle(propHandle));
auto const propInitVec = v.makeReg();
auto const propData = v.makeReg();
v << load{Vreg(rvmtl())[propHandle], propInitVec};
v << load{propInitVec[Class::PropInitVec::dataOff()], propData};
auto const propsOff = sizeof(ObjectData) + cls->builtinODTailSize();
auto args = argGroup(env, inst)
.addr(obj, safe_cast<int32_t>(propsOff))
.reg(propData);
if (!cls->hasDeepInitProps()) {
cgCallHelper(v, env, CallSpec::direct(memcpy), kVoidDest,
SyncOptions::None, args.imm(cellsToBytes(nprops)));
} else {
cgCallHelper(v, env, CallSpec::direct(deepInitHelper),
kVoidDest, SyncOptions::None, args.imm(nprops));
}
}
}
}
APCHandle::Pair APCObject::Construct(ObjectData* objectData) {
// This function assumes the object and object/array down the tree have no
// internal references and do not implement the serializable interface.
assert(!objectData->instanceof(SystemLib::s_SerializableClass));
auto cls = objectData->getVMClass();
auto clsOrName = make_class(cls);
if (clsOrName.right()) return ConstructSlow(objectData, clsOrName);
// We have a persistent Class. Build an array of APCHandle* to mirror the
// declared properties in the object.
auto const propInfo = cls->declProperties();
auto const hasDynProps = objectData->hasDynProps();
auto const numRealProps = propInfo.size();
auto const numApcProps = numRealProps + hasDynProps;
auto size = sizeof(APCObject) + sizeof(APCHandle*) * numApcProps;
auto const apcObj = new (malloc_huge(size)) APCObject(clsOrName, numApcProps);
apcObj->m_persistent = 1;
// Set a few more flags for faster fetching: whether or not the object has a
// wakeup method, and whether or not we can use a fast path that avoids
// default-initializing properties before setting them to their APC values.
if (!cls->lookupMethod(s___wakeup.get())) apcObj->m_no_wakeup = 1;
if (!cls->instanceCtor()) {
apcObj->m_fast_init = 1;
}
auto const apcPropVec = apcObj->persistentProps();
auto const objPropVec = objectData->propVec();
const TypedValueAux* propInit = nullptr;
for (unsigned i = 0; i < numRealProps; ++i) {
auto const attrs = propInfo[i].attrs;
assert((attrs & AttrStatic) == 0);
const TypedValue* objProp;
if (attrs & AttrBuiltin) {
// Special properties like the Memoize cache should be set to their
// default value, not the current value.
if (propInit == nullptr) {
propInit = cls->pinitVec().empty() ? &cls->declPropInit()[0]
: &(*cls->getPropData())[0];
}
objProp = propInit + i;
} else {
objProp = objPropVec + i;
}
auto val = APCHandle::Create(tvAsCVarRef(objProp), false,
APCHandleLevel::Inner, true);
size += val.size;
apcPropVec[i] = val.handle;
}
if (UNLIKELY(hasDynProps)) {
auto val = APCHandle::Create(objectData->dynPropArray(), false,
APCHandleLevel::Inner, true);
size += val.size;
apcPropVec[numRealProps] = val.handle;
}
return {apcObj->getHandle(), size};
}
