Cell GlobalsArray::NvGetKey(const ArrayData* ad, ssize_t pos) { auto a = asGlobals(ad); NameValueTable::Iterator iter(a->m_tab, pos); if (iter.valid()) { auto k = iter.curKey(); if (k->isRefCounted()) { k->rawIncRefCount(); return make_tv<KindOfString>(const_cast<StringData*>(k)); } return make_tv<KindOfPersistentString>(k); } return make_tv<KindOfUninit>(); }
void initInstructions(Trace* trace, IRInstruction::List& wl) { IRInstruction::List instructions = trace->getInstructionList(); IRInstruction::Iterator it; bool unreachable = false; TRACE(5, "DCE:vvvvvvvvvvvvvvvvvvvv\n"); for (it = instructions.begin(); it != instructions.end(); it++) { IRInstruction* inst = *it; ASSERT(inst->getParent() == trace); Simplifier::copyProp(inst); // if this is a load that does not generate a guard, then get rid // of its label so that its not an essential control-flow // instruction if (isUnguardedLoad(inst)) { // LdStack and LdLoc instructions that produce generic types // and LdStack instruction that produce Cell types will not // generate guards, so remove the label from this instruction so // that its no longer an essential control-flow instruction inst->setLabel(NULL); } Opcode opc = inst->getOpcode(); // decref of anything that isn't ref counted is a nop if ((opc == DecRef || opc == DecRefNZ) && !isRefCounted(inst->getSrc(0))) { inst->setId(DEAD); continue; } if (!unreachable && inst->isControlFlowInstruction()) { // mark the destination label so that the destination trace // is marked reachable inst->getLabel()->setId(LIVE); } if (!unreachable && isEssential(inst)) { inst->setId(LIVE); wl.push_back(inst); } else { if (moduleEnabled(HPHP::Trace::hhir, 5)) { std::ostringstream ss1; inst->printSrcs(ss1); TRACE(5, "DCE: %s\n", ss1.str().c_str()); std::ostringstream ss2; inst->print(ss2); TRACE(5, "DCE: %s\n", ss2.str().c_str()); } inst->setId(DEAD); } if (inst->getOpcode() == Jmp_) { unreachable = true; } } TRACE(5, "DCE:^^^^^^^^^^^^^^^^^^^^\n"); }
void CanRunScriptChecker::registerMatchers(MatchFinder *AstMatcher) { auto InvalidArg = // We want to find any expression, ignoreTrivials(expr( // which has a refcounted pointer type, hasType(pointerType( pointee(hasDeclaration(cxxRecordDecl(isRefCounted()))))), // and which is not this, unless(cxxThisExpr()), // and which is not a method call on a smart ptr, unless(cxxMemberCallExpr(on(hasType(isSmartPtrToRefCounted())))), // and which is not a parameter of the parent function, unless(declRefExpr(to(parmVarDecl()))), // and which is not a MOZ_KnownLive wrapped value. unless(callExpr(callee(functionDecl(hasName("MOZ_KnownLive"))))), expr().bind("invalidArg"))); auto OptionalInvalidExplicitArg = anyOf( // We want to find any argument which is invalid. hasAnyArgument(InvalidArg), // This makes this matcher optional. anything()); // Please not that the hasCanRunScriptAnnotation() matchers are not present // directly in the cxxMemberCallExpr, callExpr and constructExpr matchers // because we check that the corresponding functions can run script later in // the checker code. AstMatcher->addMatcher( expr( anyOf( // We want to match a method call expression, cxxMemberCallExpr( // which optionally has an invalid arg, OptionalInvalidExplicitArg, // or which optionally has an invalid implicit this argument, anyOf( // which derefs into an invalid arg, on(cxxOperatorCallExpr( anyOf(hasAnyArgument(InvalidArg), anything()))), // or is an invalid arg. on(InvalidArg), anything()), expr().bind("callExpr")), // or a regular call expression, callExpr( // which optionally has an invalid arg. OptionalInvalidExplicitArg, expr().bind("callExpr")), // or a construct expression, cxxConstructExpr( // which optionally has an invalid arg. OptionalInvalidExplicitArg, expr().bind("constructExpr"))), anyOf( // We want to match the parent function. forFunction(functionDecl().bind("nonCanRunScriptParentFunction")), // ... optionally. anything())), this); }