コード例 #1
0
ExpressionPtr ConstantExpression::preOptimize(AnalysisResultConstPtr ar) {
    if (ar->getPhase() < AnalysisResult::FirstPreOptimize) {
        return ExpressionPtr();
    }
    ConstructPtr decl;
    while (!isScalar() && !m_dynamic && !(m_context & LValue)) {
        const Symbol *sym = resolveNS(ar);
        if (sym &&
                (!const_cast<Symbol*>(sym)->checkDefined() || sym->isDynamic())) {
            sym = 0;
            m_dynamic = true;
        }
        if (!sym) break;
        if (!sym->isSystem()) BlockScope::s_constMutex.lock();
        ExpressionPtr value = dynamic_pointer_cast<Expression>(sym->getValue());
        if (!sym->isSystem()) BlockScope::s_constMutex.unlock();

        if (!value || !value->isScalar()) {
            if (!m_depsSet && sym->getDeclaration()) {
                sym->getDeclaration()->getScope()->addUse(
                    getScope(), BlockScope::UseKindConstRef);
                m_depsSet = true;
            }
            break;
        }

        Variant scalarValue;
        if (value->getScalarValue(scalarValue) &&
                !scalarValue.isAllowedAsConstantValue()) {
            // block further optimization
            const_cast<Symbol*>(sym)->setDynamic();
            m_dynamic = true;
            break;
        }

        if (sym->isSystem() && !value->is(KindOfScalarExpression)) {
            if (ExpressionPtr opt = value->preOptimize(ar)) {
                value = opt;
            }
        }
        ExpressionPtr rep = Clone(value, getScope());
        rep->setComment(getText());
        copyLocationTo(rep);
        return replaceValue(rep);
    }

    return ExpressionPtr();
}
コード例 #2
0
ExpressionPtr ClassConstantExpression::preOptimize(AnalysisResultConstPtr ar) {
  if (ar->getPhase() < AnalysisResult::FirstPreOptimize) {
    return ExpressionPtr();
  }
  if (m_class) {
    updateClassName();
    if (m_class) {
      return ExpressionPtr();
    }
  }

  ClassScopePtr cls = resolveClass();
  if (!cls || (cls->isVolatile() && !isPresent())) {
    if (cls && !m_depsSet) {
      cls->addUse(getScope(), BlockScope::UseKindConstRef);
      m_depsSet = true;
    }
    return ExpressionPtr();
  }

  ConstantTablePtr constants = cls->getConstants();
  ClassScopePtr defClass = cls;
  ConstructPtr decl = constants->getValueRecur(ar, m_varName, defClass);
  if (decl) {
    BlockScope::s_constMutex.lock();
    ExpressionPtr value = dynamic_pointer_cast<Expression>(decl);
    BlockScope::s_constMutex.unlock();

    if (!value->isScalar() &&
        (value->is(KindOfClassConstantExpression) ||
         value->is(KindOfConstantExpression))) {
      std::set<ExpressionPtr> seen;
      do {
        if (!seen.insert(value).second) return ExpressionPtr();
        value = value->preOptimize(ar);
        if (!value) return ExpressionPtr();
      } while (!value->isScalar() &&
               (value->is(KindOfClassConstantExpression) ||
                value->is(KindOfConstantExpression)));
    }

    ExpressionPtr rep = Clone(value, getScope());
    rep->setComment(getText());
    copyLocationTo(rep);
    return replaceValue(rep);
  }
  return ExpressionPtr();
}
コード例 #3
0
ExpressionPtr ClassConstantExpression::preOptimize(AnalysisResultPtr ar) {
  if (ar->getPhase() < AnalysisResult::FirstPreOptimize) {
    return ExpressionPtr();
  }
  if (m_redeclared) return ExpressionPtr();
  ClassScopePtr cls = ar->resolveClass(m_className);
  if (!cls || cls->isRedeclaring()) return ExpressionPtr();
  ConstantTablePtr constants = cls->getConstants();
  if (constants->isExplicitlyDeclared(m_varName)) {
    ConstructPtr decl = constants->getValue(m_varName);
    if (decl) {
      ExpressionPtr value = dynamic_pointer_cast<Expression>(decl);
      if (!m_visited) {
        m_visited = true;
        ar->pushScope(cls);
        ExpressionPtr optExp = value->preOptimize(ar);
        ar->popScope();
        m_visited = false;
        if (optExp) value = optExp;
      }
      if (value->isScalar()) {
        // inline the value
        if (value->is(Expression::KindOfScalarExpression)) {
          ScalarExpressionPtr exp =
            dynamic_pointer_cast<ScalarExpression>(Clone(value));
          exp->setComment(getText());
          return exp;
        } else if (value->is(Expression::KindOfConstantExpression)) {
          // inline the value
          ConstantExpressionPtr exp =
            dynamic_pointer_cast<ConstantExpression>(Clone(value));
          exp->setComment(getText());
          return exp;
        }
      }
    }
  }
  return ExpressionPtr();
}
コード例 #4
0
ファイル: analysis_result.cpp プロジェクト: Globalcherry/hhvm
ExpressionPtr DepthFirstVisitor<Pre, OptVisitor>::visit(ExpressionPtr e) {
  return e->preOptimize(this->m_data.m_ar);
}