int ForStatement::inlineCost(InlineCostState *ics)
{
//return COST_MAX;
int cost = STATEMENT_COST;
if (init)
cost += init->inlineCost(ics);
if (condition)
cost += expressionInlineCost(condition, ics);
if (increment)
cost += expressionInlineCost(increment, ics);
if (body)
cost += body->inlineCost(ics);
//printf("ForStatement: inlineCost = %d\n", cost);
return cost;
}
Expression *Expression::inlineCopy(Scope *sc)
{
#if 0
/* See Bugzilla 2935 for explanation of why just a copy() is broken
*/
return copy();
#else
if (op == TOKdelegate)
{ DelegateExp *de = (DelegateExp *)this;
if (de->func->isNested())
{ /* See Bugzilla 4820
* Defer checking until later if we actually need the 'this' pointer
*/
Expression *e = de->copy();
return e;
}
}
InlineCostState ics;
memset(&ics, 0, sizeof(ics));
ics.hdrscan = 1; // so DeclarationExp:: will work on 'statics' which are not
int cost = expressionInlineCost(this, &ics);
if (cost >= COST_MAX)
{ error("cannot inline default argument %s", toChars());
return new ErrorExp();
}
InlineDoState ids;
memset(&ids, 0, sizeof(ids));
ids.parent = sc->parent;
Expression *e = doInline(&ids);
return e;
#endif
}
int ReturnStatement::inlineCost(InlineCostState *ics)
{
// Can't handle return statements nested in if's
if (ics->nested)
return COST_MAX;
return expressionInlineCost(exp, ics);
}
int DeclarationExp::inlineCost3(InlineCostState *ics)
{ int cost = 0;
VarDeclaration *vd;
//printf("DeclarationExp::inlineCost3()\n");
vd = declaration->isVarDeclaration();
if (vd)
{
TupleDeclaration *td = vd->toAlias()->isTupleDeclaration();
if (td)
{
#if 1
return COST_MAX; // finish DeclarationExp::doInline
#else
for (size_t i = 0; i < td->objects->dim; i++)
{ Object *o = (*td->objects)[i];
if (o->dyncast() != DYNCAST_EXPRESSION)
return COST_MAX;
Expression *eo = (Expression *)o;
if (eo->op != TOKdsymbol)
return COST_MAX;
}
return td->objects->dim;
#endif
}
if (!ics->hdrscan && vd->isDataseg())
return COST_MAX;
cost += 1;
#if DMDV2
if (vd->edtor) // if destructor required
return COST_MAX; // needs work to make this work
#endif
// Scan initializer (vd->init)
if (vd->init)
{
ExpInitializer *ie = vd->init->isExpInitializer();
if (ie)
{
cost += expressionInlineCost(ie->exp, ics);
}
}
}
// These can contain functions, which when copied, get output twice.
if (declaration->isStructDeclaration() ||
declaration->isClassDeclaration() ||
declaration->isFuncDeclaration() ||
declaration->isTypedefDeclaration() ||
#if DMDV2
declaration->isAttribDeclaration() ||
#endif
declaration->isTemplateMixin())
return COST_MAX;
//printf("DeclarationExp::inlineCost3('%s')\n", toChars());
return cost;
}
void visit(ReturnStatement *s)
{
// Can't handle return statements nested in if's
if (nested)
{
cost = COST_MAX;
}
else
{
expressionInlineCost(s->exp);
}
}
void visit(DeclarationExp *e)
{
//printf("DeclarationExp::inlineCost3()\n");
VarDeclaration *vd = e->declaration->isVarDeclaration();
if (vd)
{
TupleDeclaration *td = vd->toAlias()->isTupleDeclaration();
if (td)
{
cost = COST_MAX; // finish DeclarationExp::doInline
return;
}
if (!hdrscan && vd->isDataseg())
{
cost = COST_MAX;
return;
}
if (vd->edtor)
{
// if destructor required
// needs work to make this work
cost = COST_MAX;
return;
}
// Scan initializer (vd->init)
if (vd->_init)
{
ExpInitializer *ie = vd->_init->isExpInitializer();
if (ie)
{
expressionInlineCost(ie->exp);
}
}
cost += 1;
}
// These can contain functions, which when copied, get output twice.
if (e->declaration->isStructDeclaration() ||
e->declaration->isClassDeclaration() ||
e->declaration->isFuncDeclaration() ||
e->declaration->isAttribDeclaration() ||
e->declaration->isTemplateMixin())
{
cost = COST_MAX;
return;
}
//printf("DeclarationExp::inlineCost3('%s')\n", toChars());
}
int IfStatement::inlineCost(InlineCostState *ics)
{
int cost;
#if !IN_LLVM
/* Can't declare variables inside ?: expressions, so
* we cannot inline if a variable is declared.
*/
if (arg)
return COST_MAX;
#endif
cost = expressionInlineCost(condition, ics);
#if !IN_LLVM
/* Specifically allow:
* if (condition)
* return exp1;
* else
* return exp2;
* Otherwise, we can't handle return statements nested in if's.
*/
if (elsebody && ifbody &&
ifbody->isReturnStatement() &&
elsebody->isReturnStatement())
{
cost += ifbody->inlineCost(ics);
cost += elsebody->inlineCost(ics);
//printf("cost = %d\n", cost);
}
else
#endif
{
ics->nested += 1;
if (ifbody)
cost += ifbody->inlineCost(ics);
if (elsebody)
cost += elsebody->inlineCost(ics);
ics->nested -= 1;
}
//printf("IfStatement::inlineCost = %d\n", cost);
return cost;
}
void visit(IfStatement *s)
{
/* Can't declare variables inside ?: expressions, so
* we cannot inline if a variable is declared.
*/
if (s->prm)
{
cost = COST_MAX;
return;
}
expressionInlineCost(s->condition);
/* Specifically allow:
* if (condition)
* return exp1;
* else
* return exp2;
* Otherwise, we can't handle return statements nested in if's.
*/
if (s->elsebody && s->ifbody &&
s->ifbody->isReturnStatement() &&
s->elsebody->isReturnStatement())
{
s->ifbody->accept(this);
s->elsebody->accept(this);
//printf("cost = %d\n", cost);
}
else
{
nested += 1;
if (s->ifbody)
s->ifbody->accept(this);
if (s->elsebody)
s->elsebody->accept(this);
nested -= 1;
}
//printf("IfStatement::inlineCost = %d\n", cost);
}
int ExpStatement::inlineCost(InlineCostState *ics)
{
return expressionInlineCost(exp, ics);
//return exp ? exp->inlineCost(ics) : 0;
}
void visit(ExpStatement *s)
{
expressionInlineCost(s->exp);
}
