Mercurial > projects > ldc
annotate dmd/inline.c @ 1194:1853dcd9b944
Moved some DMDFE files into a seperate dmd/root subdir to closer match the DMD file structure since 1.041.
| author | Tomas Lindquist Olsen <tomas.l.olsen gmail.com> |
|---|---|
| date | Fri, 03 Apr 2009 17:02:52 +0200 |
| parents | 1860414bf3b7 |
| children | 8026319762be |
| rev | line source |
|---|---|
| 1 | 1 |
| 2 // Copyright (c) 1999-2007 by Digital Mars | |
| 3 // All Rights Reserved | |
| 4 // written by Walter Bright | |
| 5 // http://www.digitalmars.com | |
| 6 // License for redistribution is by either the Artistic License | |
| 7 // in artistic.txt, or the GNU General Public License in gnu.txt. | |
| 8 // See the included readme.txt for details. | |
| 9 | |
| 10 // Routines to perform function inlining | |
| 11 | |
| 12 #define LOG 0 | |
| 13 | |
| 14 #include <stdio.h> | |
| 15 #include <stdlib.h> | |
| 16 #include <assert.h> | |
| 17 | |
| 18 #include "id.h" | |
| 19 #include "init.h" | |
| 20 #include "declaration.h" | |
| 21 #include "aggregate.h" | |
| 22 #include "expression.h" | |
| 23 #include "statement.h" | |
| 24 #include "mtype.h" | |
| 25 | |
| 26 /* ========== Compute cost of inlining =============== */ | |
| 27 | |
| 28 /* Walk trees to determine if inlining can be done, and if so, | |
| 29 * if it is too complex to be worth inlining or not. | |
| 30 */ | |
| 31 | |
| 32 struct InlineCostState | |
| 33 { | |
| 34 int nested; | |
| 35 int hasthis; | |
| 36 int hdrscan; // !=0 if inline scan for 'header' content | |
| 37 FuncDeclaration *fd; | |
| 38 }; | |
| 39 | |
| 40 const int COST_MAX = 250; | |
| 41 | |
| 42 int Statement::inlineCost(InlineCostState *ics) | |
| 43 { | |
| 44 return COST_MAX; // default is we can't inline it | |
| 45 } | |
| 46 | |
| 47 int ExpStatement::inlineCost(InlineCostState *ics) | |
| 48 { | |
| 49 return exp ? exp->inlineCost(ics) : 0; | |
| 50 } | |
| 51 | |
| 52 int CompoundStatement::inlineCost(InlineCostState *ics) | |
| 53 { int cost = 0; | |
| 54 | |
| 55 for (size_t i = 0; i < statements->dim; i++) | |
| 56 { Statement *s = (Statement *) statements->data[i]; | |
| 57 if (s) | |
| 58 { | |
| 59 cost += s->inlineCost(ics); | |
| 60 if (cost >= COST_MAX) | |
| 61 break; | |
| 62 } | |
| 63 } | |
| 64 return cost; | |
| 65 } | |
| 66 | |
| 67 int UnrolledLoopStatement::inlineCost(InlineCostState *ics) | |
| 68 { int cost = 0; | |
| 69 | |
| 70 for (size_t i = 0; i < statements->dim; i++) | |
| 71 { Statement *s = (Statement *) statements->data[i]; | |
| 72 if (s) | |
| 73 { | |
| 74 cost += s->inlineCost(ics); | |
| 75 if (cost >= COST_MAX) | |
| 76 break; | |
| 77 } | |
| 78 } | |
| 79 return cost; | |
| 80 } | |
| 81 | |
| 82 int IfStatement::inlineCost(InlineCostState *ics) | |
| 83 { | |
| 84 int cost; | |
| 85 | |
| 86 /* Can't declare variables inside ?: expressions, so | |
| 87 * we cannot inline if a variable is declared. | |
| 88 */ | |
| 89 if (arg) | |
| 90 return COST_MAX; | |
| 91 | |
| 92 cost = condition->inlineCost(ics); | |
| 93 | |
| 94 /* Specifically allow: | |
| 95 * if (condition) | |
| 96 * return exp1; | |
| 97 * else | |
| 98 * return exp2; | |
| 99 * Otherwise, we can't handle return statements nested in if's. | |
| 100 */ | |
| 101 | |
| 102 if (elsebody && ifbody && | |
| 103 ifbody->isReturnStatement() && | |
| 104 elsebody->isReturnStatement()) | |
| 105 { | |
| 106 cost += ifbody->inlineCost(ics); | |
| 107 cost += elsebody->inlineCost(ics); | |
| 108 //printf("cost = %d\n", cost); | |
| 109 } | |
| 110 else | |
| 111 { | |
| 112 ics->nested += 1; | |
| 113 if (ifbody) | |
| 114 cost += ifbody->inlineCost(ics); | |
| 115 if (elsebody) | |
| 116 cost += elsebody->inlineCost(ics); | |
| 117 ics->nested -= 1; | |
| 118 } | |
| 119 return cost; | |
| 120 } | |
| 121 | |
| 122 int ReturnStatement::inlineCost(InlineCostState *ics) | |
| 123 { | |
| 124 // Can't handle return statements nested in if's | |
| 125 if (ics->nested) | |
| 126 return COST_MAX; | |
| 127 return exp ? exp->inlineCost(ics) : 0; | |
| 128 } | |
| 129 | |
| 130 /* -------------------------- */ | |
| 131 | |
| 132 int arrayInlineCost(InlineCostState *ics, Array *arguments) | |
| 133 { int cost = 0; | |
| 134 | |
| 135 if (arguments) | |
| 136 { | |
| 137 for (int i = 0; i < arguments->dim; i++) | |
| 138 { Expression *e = (Expression *)arguments->data[i]; | |
| 139 | |
| 140 if (e) | |
| 141 cost += e->inlineCost(ics); | |
| 142 } | |
| 143 } | |
| 144 return cost; | |
| 145 } | |
| 146 | |
| 147 int Expression::inlineCost(InlineCostState *ics) | |
| 148 { | |
| 149 return 1; | |
| 150 } | |
| 151 | |
| 152 int VarExp::inlineCost(InlineCostState *ics) | |
| 153 { | |
| 154 //printf("VarExp::inlineCost() %s\n", toChars()); | |
| 155 return 1; | |
| 156 } | |
| 157 | |
| 158 int ThisExp::inlineCost(InlineCostState *ics) | |
| 159 { | |
| 160 FuncDeclaration *fd = ics->fd; | |
| 161 if (!ics->hdrscan) | |
| 162 if (fd->isNested() || !ics->hasthis) | |
| 163 return COST_MAX; | |
| 164 return 1; | |
| 165 } | |
| 166 | |
| 167 int SuperExp::inlineCost(InlineCostState *ics) | |
| 168 { | |
| 169 FuncDeclaration *fd = ics->fd; | |
| 170 if (!ics->hdrscan) | |
| 171 if (fd->isNested() || !ics->hasthis) | |
| 172 return COST_MAX; | |
| 173 return 1; | |
| 174 } | |
| 175 | |
| 176 int TupleExp::inlineCost(InlineCostState *ics) | |
| 177 { | |
| 178 return 1 + arrayInlineCost(ics, exps); | |
| 179 } | |
| 180 | |
| 181 int ArrayLiteralExp::inlineCost(InlineCostState *ics) | |
| 182 { | |
| 183 return 1 + arrayInlineCost(ics, elements); | |
| 184 } | |
| 185 | |
| 186 int AssocArrayLiteralExp::inlineCost(InlineCostState *ics) | |
| 187 { | |
| 188 return 1 + arrayInlineCost(ics, keys) + arrayInlineCost(ics, values); | |
| 189 } | |
| 190 | |
| 191 int StructLiteralExp::inlineCost(InlineCostState *ics) | |
| 192 { | |
| 193 return 1 + arrayInlineCost(ics, elements); | |
| 194 } | |
| 195 | |
| 196 int FuncExp::inlineCost(InlineCostState *ics) | |
| 197 { | |
| 198 // Right now, this makes the function be output to the .obj file twice. | |
| 199 return COST_MAX; | |
| 200 } | |
| 201 | |
| 202 int DelegateExp::inlineCost(InlineCostState *ics) | |
| 203 { | |
| 204 return COST_MAX; | |
| 205 } | |
| 206 | |
| 207 int DeclarationExp::inlineCost(InlineCostState *ics) | |
| 208 { int cost = 0; | |
| 209 VarDeclaration *vd; | |
| 210 | |
| 211 //printf("DeclarationExp::inlineCost()\n"); | |
| 212 vd = declaration->isVarDeclaration(); | |
| 213 if (vd) | |
| 214 { | |
| 215 TupleDeclaration *td = vd->toAlias()->isTupleDeclaration(); | |
| 216 if (td) | |
| 217 { | |
| 218 #if 1 | |
| 219 return COST_MAX; // finish DeclarationExp::doInline | |
| 220 #else | |
| 221 for (size_t i = 0; i < td->objects->dim; i++) | |
| 222 { Object *o = (Object *)td->objects->data[i]; | |
| 223 if (o->dyncast() != DYNCAST_EXPRESSION) | |
| 224 return COST_MAX; | |
| 225 Expression *eo = (Expression *)o; | |
| 226 if (eo->op != TOKdsymbol) | |
| 227 return COST_MAX; | |
| 228 } | |
| 229 return td->objects->dim; | |
| 230 #endif | |
| 231 } | |
| 232 if (!ics->hdrscan && vd->isDataseg()) | |
| 233 return COST_MAX; | |
| 234 cost += 1; | |
| 235 | |
| 236 // Scan initializer (vd->init) | |
| 237 if (vd->init) | |
| 238 { | |
| 239 ExpInitializer *ie = vd->init->isExpInitializer(); | |
| 240 | |
| 241 if (ie) | |
| 242 { | |
| 243 cost += ie->exp->inlineCost(ics); | |
| 244 } | |
| 245 } | |
| 246 } | |
| 247 | |
| 248 // These can contain functions, which when copied, get output twice. | |
| 249 if (declaration->isStructDeclaration() || | |
| 250 declaration->isClassDeclaration() || | |
| 251 declaration->isFuncDeclaration() || | |
| 252 declaration->isTypedefDeclaration() || | |
| 253 declaration->isTemplateMixin()) | |
| 254 return COST_MAX; | |
| 255 | |
| 256 //printf("DeclarationExp::inlineCost('%s')\n", toChars()); | |
| 257 return cost; | |
| 258 } | |
| 259 | |
| 260 int UnaExp::inlineCost(InlineCostState *ics) | |
| 261 { | |
| 262 return 1 + e1->inlineCost(ics); | |
| 263 } | |
| 264 | |
| 265 int AssertExp::inlineCost(InlineCostState *ics) | |
| 266 { | |
| 267 return 1 + e1->inlineCost(ics) + (msg ? msg->inlineCost(ics) : 0); | |
| 268 } | |
| 269 | |
| 270 int BinExp::inlineCost(InlineCostState *ics) | |
| 271 { | |
| 272 return 1 + e1->inlineCost(ics) + e2->inlineCost(ics); | |
| 273 } | |
| 274 | |
| 275 int CallExp::inlineCost(InlineCostState *ics) | |
| 276 { | |
| 277 return 1 + e1->inlineCost(ics) + arrayInlineCost(ics, arguments); | |
| 278 } | |
| 279 | |
| 280 int SliceExp::inlineCost(InlineCostState *ics) | |
| 281 { int cost; | |
| 282 | |
| 283 cost = 1 + e1->inlineCost(ics); | |
| 284 if (lwr) | |
| 285 cost += lwr->inlineCost(ics); | |
| 286 if (upr) | |
| 287 cost += upr->inlineCost(ics); | |
| 288 return cost; | |
| 289 } | |
| 290 | |
| 291 int ArrayExp::inlineCost(InlineCostState *ics) | |
| 292 { | |
| 293 return 1 + e1->inlineCost(ics) + arrayInlineCost(ics, arguments); | |
| 294 } | |
| 295 | |
| 296 | |
| 297 int CondExp::inlineCost(InlineCostState *ics) | |
| 298 { | |
| 299 return 1 + | |
| 300 e1->inlineCost(ics) + | |
| 301 e2->inlineCost(ics) + | |
| 302 econd->inlineCost(ics); | |
| 303 } | |
| 304 | |
| 305 | |
| 306 /* ======================== Perform the inlining ============================== */ | |
| 307 | |
| 308 /* Inlining is done by: | |
| 309 * o Converting to an Expression | |
| 310 * o Copying the trees of the function to be inlined | |
| 311 * o Renaming the variables | |
| 312 */ | |
| 313 | |
| 314 struct InlineDoState | |
| 315 { | |
| 316 VarDeclaration *vthis; | |
| 317 Array from; // old Dsymbols | |
| 318 Array to; // parallel array of new Dsymbols | |
| 319 Dsymbol *parent; // new parent | |
| 320 }; | |
| 321 | |
| 322 Expression *Statement::doInline(InlineDoState *ids) | |
| 323 { | |
| 324 assert(0); | |
| 325 return NULL; // default is we can't inline it | |
| 326 } | |
| 327 | |
| 328 Expression *ExpStatement::doInline(InlineDoState *ids) | |
| 329 { | |
| 330 #if LOG | |
| 331 if (exp) printf("ExpStatement::doInline() '%s'\n", exp->toChars()); | |
| 332 #endif | |
| 333 return exp ? exp->doInline(ids) : NULL; | |
| 334 } | |
| 335 | |
| 336 Expression *CompoundStatement::doInline(InlineDoState *ids) | |
| 337 { | |
| 338 Expression *e = NULL; | |
| 339 | |
| 340 //printf("CompoundStatement::doInline() %d\n", statements->dim); | |
| 341 for (size_t i = 0; i < statements->dim; i++) | |
| 342 { Statement *s = (Statement *) statements->data[i]; | |
| 343 if (s) | |
| 344 { | |
| 345 Expression *e2 = s->doInline(ids); | |
| 346 e = Expression::combine(e, e2); | |
| 347 if (s->isReturnStatement()) | |
| 348 break; | |
| 349 | |
| 350 /* Check for: | |
| 351 * if (condition) | |
| 352 * return exp1; | |
| 353 * else | |
| 354 * return exp2; | |
| 355 */ | |
| 356 IfStatement *ifs = s->isIfStatement(); | |
| 357 if (ifs && ifs->elsebody && ifs->ifbody && | |
| 358 ifs->ifbody->isReturnStatement() && | |
| 359 ifs->elsebody->isReturnStatement() | |
| 360 ) | |
| 361 break; | |
| 362 | |
| 363 } | |
| 364 } | |
| 365 return e; | |
| 366 } | |
| 367 | |
| 368 Expression *UnrolledLoopStatement::doInline(InlineDoState *ids) | |
| 369 { | |
| 370 Expression *e = NULL; | |
| 371 | |
| 372 //printf("UnrolledLoopStatement::doInline() %d\n", statements->dim); | |
| 373 for (size_t i = 0; i < statements->dim; i++) | |
| 374 { Statement *s = (Statement *) statements->data[i]; | |
| 375 if (s) | |
| 376 { | |
| 377 Expression *e2 = s->doInline(ids); | |
| 378 e = Expression::combine(e, e2); | |
| 379 if (s->isReturnStatement()) | |
| 380 break; | |
| 381 } | |
| 382 } | |
| 383 return e; | |
| 384 } | |
| 385 | |
| 386 Expression *IfStatement::doInline(InlineDoState *ids) | |
| 387 { | |
| 388 Expression *econd; | |
| 389 Expression *e1; | |
| 390 Expression *e2; | |
| 391 Expression *e; | |
| 392 | |
| 393 assert(!arg); | |
| 394 econd = condition->doInline(ids); | |
| 395 assert(econd); | |
| 396 if (ifbody) | |
| 397 e1 = ifbody->doInline(ids); | |
| 398 else | |
| 399 e1 = NULL; | |
| 400 if (elsebody) | |
| 401 e2 = elsebody->doInline(ids); | |
| 402 else | |
| 403 e2 = NULL; | |
| 404 if (e1 && e2) | |
| 405 { | |
| 406 e = new CondExp(econd->loc, econd, e1, e2); | |
| 407 e->type = e1->type; | |
| 408 } | |
| 409 else if (e1) | |
| 410 { | |
| 411 e = new AndAndExp(econd->loc, econd, e1); | |
| 412 e->type = Type::tvoid; | |
| 413 } | |
| 414 else if (e2) | |
| 415 { | |
| 416 e = new OrOrExp(econd->loc, econd, e2); | |
| 417 e->type = Type::tvoid; | |
| 418 } | |
| 419 else | |
| 420 { | |
| 421 e = econd; | |
| 422 } | |
| 423 return e; | |
| 424 } | |
| 425 | |
| 426 Expression *ReturnStatement::doInline(InlineDoState *ids) | |
| 427 { | |
| 428 //printf("ReturnStatement::doInline() '%s'\n", exp ? exp->toChars() : ""); | |
| 429 return exp ? exp->doInline(ids) : 0; | |
| 430 } | |
| 431 | |
| 432 /* --------------------------------------------------------------- */ | |
| 433 | |
| 434 /****************************** | |
| 435 * Perform doInline() on an array of Expressions. | |
| 436 */ | |
| 437 | |
| 438 Expressions *arrayExpressiondoInline(Expressions *a, InlineDoState *ids) | |
| 439 { Expressions *newa = NULL; | |
| 440 | |
| 441 if (a) | |
| 442 { | |
| 443 newa = new Expressions(); | |
| 444 newa->setDim(a->dim); | |
| 445 | |
| 446 for (int i = 0; i < a->dim; i++) | |
| 447 { Expression *e = (Expression *)a->data[i]; | |
| 448 | |
| 449 if (e) | |
| 450 { | |
| 451 e = e->doInline(ids); | |
| 452 newa->data[i] = (void *)e; | |
| 453 } | |
| 454 } | |
| 455 } | |
| 456 return newa; | |
| 457 } | |
| 458 | |
| 459 Expression *Expression::doInline(InlineDoState *ids) | |
| 460 { | |
| 461 //printf("Expression::doInline(%s): %s\n", Token::toChars(op), toChars()); | |
| 462 return copy(); | |
| 463 } | |
| 464 | |
| 465 Expression *SymOffExp::doInline(InlineDoState *ids) | |
| 466 { | |
| 467 int i; | |
| 468 | |
| 469 //printf("SymOffExp::doInline(%s)\n", toChars()); | |
| 470 for (i = 0; i < ids->from.dim; i++) | |
| 471 { | |
| 472 if (var == (Declaration *)ids->from.data[i]) | |
| 473 { | |
| 474 SymOffExp *se = (SymOffExp *)copy(); | |
| 475 | |
| 476 se->var = (Declaration *)ids->to.data[i]; | |
| 477 return se; | |
| 478 } | |
| 479 } | |
| 480 return this; | |
| 481 } | |
| 482 | |
| 483 Expression *VarExp::doInline(InlineDoState *ids) | |
| 484 { | |
| 485 int i; | |
| 486 | |
| 487 //printf("VarExp::doInline(%s)\n", toChars()); | |
| 488 for (i = 0; i < ids->from.dim; i++) | |
| 489 { | |
| 490 if (var == (Declaration *)ids->from.data[i]) | |
| 491 { | |
| 492 VarExp *ve = (VarExp *)copy(); | |
| 493 | |
| 494 ve->var = (Declaration *)ids->to.data[i]; | |
| 495 return ve; | |
| 496 } | |
| 497 } | |
| 498 return this; | |
| 499 } | |
| 500 | |
| 501 Expression *ThisExp::doInline(InlineDoState *ids) | |
| 502 { | |
| 503 //if (!ids->vthis) | |
| 504 //error("no 'this' when inlining %s", ids->parent->toChars()); | |
| 505 if (!ids->vthis) | |
| 506 { | |
| 507 return this; | |
| 508 } | |
| 509 | |
| 510 VarExp *ve = new VarExp(loc, ids->vthis); | |
| 511 ve->type = type; | |
| 512 return ve; | |
| 513 } | |
| 514 | |
| 515 Expression *SuperExp::doInline(InlineDoState *ids) | |
| 516 { | |
| 517 assert(ids->vthis); | |
| 518 | |
| 519 VarExp *ve = new VarExp(loc, ids->vthis); | |
| 520 ve->type = type; | |
| 521 return ve; | |
| 522 } | |
| 523 | |
| 524 Expression *DeclarationExp::doInline(InlineDoState *ids) | |
| 525 { DeclarationExp *de = (DeclarationExp *)copy(); | |
| 526 VarDeclaration *vd; | |
| 527 | |
| 528 //printf("DeclarationExp::doInline(%s)\n", toChars()); | |
| 529 vd = declaration->isVarDeclaration(); | |
| 530 if (vd) | |
| 531 { | |
| 532 #if 0 | |
| 533 // Need to figure this out before inlining can work for tuples | |
| 534 TupleDeclaration *td = vd->toAlias()->isTupleDeclaration(); | |
| 535 if (td) | |
| 536 { | |
| 537 for (size_t i = 0; i < td->objects->dim; i++) | |
| 538 { DsymbolExp *se = (DsymbolExp *)td->objects->data[i]; | |
| 539 assert(se->op == TOKdsymbol); | |
| 540 se->s; | |
| 541 } | |
| 542 return st->objects->dim; | |
| 543 } | |
| 544 #endif | |
| 545 if (vd->isStatic() || vd->isConst()) | |
| 546 ; | |
| 547 else | |
| 548 { | |
| 549 VarDeclaration *vto; | |
| 550 | |
| 551 vto = new VarDeclaration(vd->loc, vd->type, vd->ident, vd->init); | |
| 552 *vto = *vd; | |
| 553 vto->parent = ids->parent; | |
|
1146
1860414bf3b7
* Moved ir/irsymbol.cpp/h into ir/irdsymbol.cpp/h.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
336
diff
changeset
|
554 #if IN_DMD |
| 1 | 555 vto->csym = NULL; |
| 556 vto->isym = NULL; | |
|
1146
1860414bf3b7
* Moved ir/irsymbol.cpp/h into ir/irdsymbol.cpp/h.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
336
diff
changeset
|
557 #endif |
| 1 | 558 |
| 559 ids->from.push(vd); | |
| 560 ids->to.push(vto); | |
| 561 | |
| 92 | 562 if (vd->init) |
| 1 | 563 { |
| 92 | 564 if (vd->init->isVoidInitializer()) |
| 565 { | |
| 566 vto->init = new VoidInitializer(vd->init->loc); | |
| 567 } | |
| 568 else | |
| 569 { | |
| 570 ExpInitializer *ie = vd->init->isExpInitializer(); | |
| 571 assert(ie); | |
| 572 vto->init = new ExpInitializer(ie->loc, ie->exp->doInline(ids)); | |
| 573 } | |
| 1 | 574 } |
| 575 de->declaration = (Dsymbol *) (void *)vto; | |
| 576 } | |
| 577 } | |
| 578 /* This needs work, like DeclarationExp::toElem(), if we are | |
| 579 * to handle TemplateMixin's. For now, we just don't inline them. | |
| 580 */ | |
| 581 return de; | |
| 582 } | |
| 583 | |
| 584 Expression *NewExp::doInline(InlineDoState *ids) | |
| 585 { | |
| 586 //printf("NewExp::doInline(): %s\n", toChars()); | |
| 587 NewExp *ne = (NewExp *)copy(); | |
| 588 | |
| 589 if (thisexp) | |
| 590 ne->thisexp = thisexp->doInline(ids); | |
| 591 ne->newargs = arrayExpressiondoInline(ne->newargs, ids); | |
| 592 ne->arguments = arrayExpressiondoInline(ne->arguments, ids); | |
| 593 return ne; | |
| 594 } | |
| 595 | |
| 596 Expression *UnaExp::doInline(InlineDoState *ids) | |
| 597 { | |
| 598 UnaExp *ue = (UnaExp *)copy(); | |
| 599 | |
| 600 ue->e1 = e1->doInline(ids); | |
| 601 return ue; | |
| 602 } | |
| 603 | |
| 604 Expression *AssertExp::doInline(InlineDoState *ids) | |
| 605 { | |
| 606 AssertExp *ae = (AssertExp *)copy(); | |
| 607 | |
| 608 ae->e1 = e1->doInline(ids); | |
| 609 if (msg) | |
| 610 ae->msg = msg->doInline(ids); | |
| 611 return ae; | |
| 612 } | |
| 613 | |
| 614 Expression *BinExp::doInline(InlineDoState *ids) | |
| 615 { | |
| 616 BinExp *be = (BinExp *)copy(); | |
| 617 | |
| 618 be->e1 = e1->doInline(ids); | |
| 619 be->e2 = e2->doInline(ids); | |
| 620 return be; | |
| 621 } | |
| 622 | |
| 623 Expression *CallExp::doInline(InlineDoState *ids) | |
| 624 { | |
| 625 CallExp *ce; | |
| 626 | |
| 627 ce = (CallExp *)copy(); | |
| 628 ce->e1 = e1->doInline(ids); | |
| 629 ce->arguments = arrayExpressiondoInline(arguments, ids); | |
| 630 return ce; | |
| 631 } | |
| 632 | |
| 633 | |
| 634 Expression *IndexExp::doInline(InlineDoState *ids) | |
| 635 { | |
| 636 IndexExp *are = (IndexExp *)copy(); | |
| 637 | |
| 638 are->e1 = e1->doInline(ids); | |
| 639 | |
| 640 if (lengthVar) | |
| 641 { //printf("lengthVar\n"); | |
| 642 VarDeclaration *vd = lengthVar; | |
| 643 ExpInitializer *ie; | |
| 644 ExpInitializer *ieto; | |
| 645 VarDeclaration *vto; | |
| 646 | |
| 647 vto = new VarDeclaration(vd->loc, vd->type, vd->ident, vd->init); | |
| 648 *vto = *vd; | |
| 649 vto->parent = ids->parent; | |
|
1146
1860414bf3b7
* Moved ir/irsymbol.cpp/h into ir/irdsymbol.cpp/h.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
336
diff
changeset
|
650 #if IN_DMD |
| 1 | 651 vto->csym = NULL; |
| 652 vto->isym = NULL; | |
|
1146
1860414bf3b7
* Moved ir/irsymbol.cpp/h into ir/irdsymbol.cpp/h.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
336
diff
changeset
|
653 #endif |
| 1 | 654 |
| 655 ids->from.push(vd); | |
| 656 ids->to.push(vto); | |
| 657 | |
| 658 if (vd->init) | |
| 659 { | |
| 660 ie = vd->init->isExpInitializer(); | |
| 661 assert(ie); | |
| 662 ieto = new ExpInitializer(ie->loc, ie->exp->doInline(ids)); | |
| 663 vto->init = ieto; | |
| 664 } | |
| 665 | |
| 666 are->lengthVar = (VarDeclaration *) (void *)vto; | |
| 667 } | |
| 668 are->e2 = e2->doInline(ids); | |
| 669 return are; | |
| 670 } | |
| 671 | |
| 672 | |
| 673 Expression *SliceExp::doInline(InlineDoState *ids) | |
| 674 { | |
| 675 SliceExp *are = (SliceExp *)copy(); | |
| 676 | |
| 677 are->e1 = e1->doInline(ids); | |
| 678 | |
| 679 if (lengthVar) | |
| 680 { //printf("lengthVar\n"); | |
| 681 VarDeclaration *vd = lengthVar; | |
| 682 ExpInitializer *ie; | |
| 683 ExpInitializer *ieto; | |
| 684 VarDeclaration *vto; | |
| 685 | |
| 686 vto = new VarDeclaration(vd->loc, vd->type, vd->ident, vd->init); | |
| 687 *vto = *vd; | |
| 688 vto->parent = ids->parent; | |
|
1146
1860414bf3b7
* Moved ir/irsymbol.cpp/h into ir/irdsymbol.cpp/h.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
336
diff
changeset
|
689 #if IN_DMD |
| 1 | 690 vto->csym = NULL; |
| 691 vto->isym = NULL; | |
|
1146
1860414bf3b7
* Moved ir/irsymbol.cpp/h into ir/irdsymbol.cpp/h.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
336
diff
changeset
|
692 #endif |
| 1 | 693 |
| 694 ids->from.push(vd); | |
| 695 ids->to.push(vto); | |
| 696 | |
| 697 if (vd->init) | |
| 698 { | |
| 699 ie = vd->init->isExpInitializer(); | |
| 700 assert(ie); | |
| 701 ieto = new ExpInitializer(ie->loc, ie->exp->doInline(ids)); | |
| 702 vto->init = ieto; | |
| 703 } | |
| 704 | |
| 705 are->lengthVar = (VarDeclaration *) (void *)vto; | |
| 706 } | |
| 707 if (lwr) | |
| 708 are->lwr = lwr->doInline(ids); | |
| 709 if (upr) | |
| 710 are->upr = upr->doInline(ids); | |
| 711 return are; | |
| 712 } | |
| 713 | |
| 714 | |
| 715 Expression *TupleExp::doInline(InlineDoState *ids) | |
| 716 { | |
| 717 TupleExp *ce; | |
| 718 | |
| 719 ce = (TupleExp *)copy(); | |
| 720 ce->exps = arrayExpressiondoInline(exps, ids); | |
| 721 return ce; | |
| 722 } | |
| 723 | |
| 724 | |
| 725 Expression *ArrayLiteralExp::doInline(InlineDoState *ids) | |
| 726 { | |
| 727 ArrayLiteralExp *ce; | |
| 728 | |
| 729 ce = (ArrayLiteralExp *)copy(); | |
| 730 ce->elements = arrayExpressiondoInline(elements, ids); | |
| 731 return ce; | |
| 732 } | |
| 733 | |
| 734 | |
| 735 Expression *AssocArrayLiteralExp::doInline(InlineDoState *ids) | |
| 736 { | |
| 737 AssocArrayLiteralExp *ce; | |
| 738 | |
| 739 ce = (AssocArrayLiteralExp *)copy(); | |
| 740 ce->keys = arrayExpressiondoInline(keys, ids); | |
| 741 ce->values = arrayExpressiondoInline(values, ids); | |
| 742 return ce; | |
| 743 } | |
| 744 | |
| 745 | |
| 746 Expression *StructLiteralExp::doInline(InlineDoState *ids) | |
| 747 { | |
| 748 StructLiteralExp *ce; | |
| 749 | |
| 750 ce = (StructLiteralExp *)copy(); | |
| 751 ce->elements = arrayExpressiondoInline(elements, ids); | |
| 752 return ce; | |
| 753 } | |
| 754 | |
| 755 | |
| 756 Expression *ArrayExp::doInline(InlineDoState *ids) | |
| 757 { | |
| 758 ArrayExp *ce; | |
| 759 | |
| 760 ce = (ArrayExp *)copy(); | |
| 761 ce->e1 = e1->doInline(ids); | |
| 762 ce->arguments = arrayExpressiondoInline(arguments, ids); | |
| 763 return ce; | |
| 764 } | |
| 765 | |
| 766 | |
| 767 Expression *CondExp::doInline(InlineDoState *ids) | |
| 768 { | |
| 769 CondExp *ce = (CondExp *)copy(); | |
| 770 | |
| 771 ce->econd = econd->doInline(ids); | |
| 772 ce->e1 = e1->doInline(ids); | |
| 773 ce->e2 = e2->doInline(ids); | |
| 774 return ce; | |
| 775 } | |
| 776 | |
| 777 | |
| 778 /* ========== Walk the parse trees, and inline expand functions ============= */ | |
| 779 | |
| 780 /* Walk the trees, looking for functions to inline. | |
| 781 * Inline any that can be. | |
| 782 */ | |
| 783 | |
| 784 struct InlineScanState | |
| 785 { | |
| 786 FuncDeclaration *fd; // function being scanned | |
| 787 }; | |
| 788 | |
| 789 Statement *Statement::inlineScan(InlineScanState *iss) | |
| 790 { | |
| 791 return this; | |
| 792 } | |
| 793 | |
| 794 Statement *ExpStatement::inlineScan(InlineScanState *iss) | |
| 795 { | |
| 796 #if LOG | |
| 797 printf("ExpStatement::inlineScan(%s)\n", toChars()); | |
| 798 #endif | |
| 799 if (exp) | |
| 800 exp = exp->inlineScan(iss); | |
| 801 return this; | |
| 802 } | |
| 803 | |
| 804 Statement *CompoundStatement::inlineScan(InlineScanState *iss) | |
| 805 { | |
| 806 for (size_t i = 0; i < statements->dim; i++) | |
| 807 { Statement *s = (Statement *) statements->data[i]; | |
| 808 if (s) | |
| 809 statements->data[i] = (void *)s->inlineScan(iss); | |
| 810 } | |
| 811 return this; | |
| 812 } | |
| 813 | |
| 814 Statement *UnrolledLoopStatement::inlineScan(InlineScanState *iss) | |
| 815 { | |
| 816 for (size_t i = 0; i < statements->dim; i++) | |
| 817 { Statement *s = (Statement *) statements->data[i]; | |
| 818 if (s) | |
| 819 statements->data[i] = (void *)s->inlineScan(iss); | |
| 820 } | |
| 821 return this; | |
| 822 } | |
| 823 | |
| 824 Statement *ScopeStatement::inlineScan(InlineScanState *iss) | |
| 825 { | |
| 826 if (statement) | |
| 827 statement = statement->inlineScan(iss); | |
| 828 return this; | |
| 829 } | |
| 830 | |
| 831 Statement *WhileStatement::inlineScan(InlineScanState *iss) | |
| 832 { | |
| 833 condition = condition->inlineScan(iss); | |
| 834 body = body ? body->inlineScan(iss) : NULL; | |
| 835 return this; | |
| 836 } | |
| 837 | |
| 838 | |
| 839 Statement *DoStatement::inlineScan(InlineScanState *iss) | |
| 840 { | |
| 841 body = body ? body->inlineScan(iss) : NULL; | |
| 842 condition = condition->inlineScan(iss); | |
| 843 return this; | |
| 844 } | |
| 845 | |
| 846 | |
| 847 Statement *ForStatement::inlineScan(InlineScanState *iss) | |
| 848 { | |
| 849 if (init) | |
| 850 init = init->inlineScan(iss); | |
| 851 if (condition) | |
| 852 condition = condition->inlineScan(iss); | |
| 853 if (increment) | |
| 854 increment = increment->inlineScan(iss); | |
| 855 body = body->inlineScan(iss); | |
| 856 return this; | |
| 857 } | |
| 858 | |
| 859 | |
| 860 Statement *ForeachStatement::inlineScan(InlineScanState *iss) | |
| 861 { | |
| 862 aggr = aggr->inlineScan(iss); | |
| 92 | 863 if (body) |
| 864 body = body->inlineScan(iss); | |
| 1 | 865 return this; |
| 866 } | |
| 867 | |
| 868 | |
| 336 | 869 #if DMDV2 |
| 1 | 870 Statement *ForeachRangeStatement::inlineScan(InlineScanState *iss) |
| 871 { | |
| 872 lwr = lwr->inlineScan(iss); | |
| 873 upr = upr->inlineScan(iss); | |
| 92 | 874 if (body) |
| 875 body = body->inlineScan(iss); | |
| 1 | 876 return this; |
| 877 } | |
| 878 #endif | |
| 879 | |
| 880 | |
| 881 Statement *IfStatement::inlineScan(InlineScanState *iss) | |
| 882 { | |
| 883 condition = condition->inlineScan(iss); | |
| 884 if (ifbody) | |
| 885 ifbody = ifbody->inlineScan(iss); | |
| 886 if (elsebody) | |
| 887 elsebody = elsebody->inlineScan(iss); | |
| 888 return this; | |
| 889 } | |
| 890 | |
| 891 | |
| 892 Statement *SwitchStatement::inlineScan(InlineScanState *iss) | |
| 893 { | |
| 894 //printf("SwitchStatement::inlineScan()\n"); | |
| 895 condition = condition->inlineScan(iss); | |
| 896 body = body ? body->inlineScan(iss) : NULL; | |
| 897 if (sdefault) | |
| 898 sdefault = (DefaultStatement *)sdefault->inlineScan(iss); | |
| 899 if (cases) | |
| 900 { | |
| 901 for (int i = 0; i < cases->dim; i++) | |
| 902 { Statement *s; | |
| 903 | |
| 904 s = (Statement *) cases->data[i]; | |
| 905 cases->data[i] = (void *)s->inlineScan(iss); | |
| 906 } | |
| 907 } | |
| 908 return this; | |
| 909 } | |
| 910 | |
| 911 | |
| 912 Statement *CaseStatement::inlineScan(InlineScanState *iss) | |
| 913 { | |
| 914 //printf("CaseStatement::inlineScan()\n"); | |
| 915 exp = exp->inlineScan(iss); | |
| 916 if (statement) | |
| 917 statement = statement->inlineScan(iss); | |
| 918 return this; | |
| 919 } | |
| 920 | |
| 921 | |
| 922 Statement *DefaultStatement::inlineScan(InlineScanState *iss) | |
| 923 { | |
| 924 if (statement) | |
| 925 statement = statement->inlineScan(iss); | |
| 926 return this; | |
| 927 } | |
| 928 | |
| 929 | |
| 930 Statement *ReturnStatement::inlineScan(InlineScanState *iss) | |
| 931 { | |
| 932 if (exp) | |
| 933 exp = exp->inlineScan(iss); | |
| 934 return this; | |
| 935 } | |
| 936 | |
| 937 | |
| 938 Statement *SynchronizedStatement::inlineScan(InlineScanState *iss) | |
| 939 { | |
| 940 if (exp) | |
| 941 exp = exp->inlineScan(iss); | |
| 942 if (body) | |
| 943 body = body->inlineScan(iss); | |
| 944 return this; | |
| 945 } | |
| 946 | |
| 947 | |
| 948 Statement *WithStatement::inlineScan(InlineScanState *iss) | |
| 949 { | |
| 950 if (exp) | |
| 951 exp = exp->inlineScan(iss); | |
| 952 if (body) | |
| 953 body = body->inlineScan(iss); | |
| 954 return this; | |
| 955 } | |
| 956 | |
| 957 | |
| 958 Statement *TryCatchStatement::inlineScan(InlineScanState *iss) | |
| 959 { | |
| 960 if (body) | |
| 961 body = body->inlineScan(iss); | |
| 962 if (catches) | |
| 963 { | |
| 964 for (int i = 0; i < catches->dim; i++) | |
| 965 { Catch *c = (Catch *)catches->data[i]; | |
| 966 | |
| 967 if (c->handler) | |
| 968 c->handler = c->handler->inlineScan(iss); | |
| 969 } | |
| 970 } | |
| 971 return this; | |
| 972 } | |
| 973 | |
| 974 | |
| 975 Statement *TryFinallyStatement::inlineScan(InlineScanState *iss) | |
| 976 { | |
| 977 if (body) | |
| 978 body = body->inlineScan(iss); | |
| 979 if (finalbody) | |
| 980 finalbody = finalbody->inlineScan(iss); | |
| 981 return this; | |
| 982 } | |
| 983 | |
| 984 | |
| 985 Statement *ThrowStatement::inlineScan(InlineScanState *iss) | |
| 986 { | |
| 987 if (exp) | |
| 988 exp = exp->inlineScan(iss); | |
| 989 return this; | |
| 990 } | |
| 991 | |
| 992 | |
| 993 Statement *VolatileStatement::inlineScan(InlineScanState *iss) | |
| 994 { | |
| 995 if (statement) | |
| 996 statement = statement->inlineScan(iss); | |
| 997 return this; | |
| 998 } | |
| 999 | |
| 1000 | |
| 1001 Statement *LabelStatement::inlineScan(InlineScanState *iss) | |
| 1002 { | |
| 1003 if (statement) | |
| 1004 statement = statement->inlineScan(iss); | |
| 1005 return this; | |
| 1006 } | |
| 1007 | |
| 1008 /* -------------------------- */ | |
| 1009 | |
| 1010 void arrayInlineScan(InlineScanState *iss, Array *arguments) | |
| 1011 { | |
| 1012 if (arguments) | |
| 1013 { | |
| 1014 for (int i = 0; i < arguments->dim; i++) | |
| 1015 { Expression *e = (Expression *)arguments->data[i]; | |
| 1016 | |
| 1017 if (e) | |
| 1018 { | |
| 1019 e = e->inlineScan(iss); | |
| 1020 arguments->data[i] = (void *)e; | |
| 1021 } | |
| 1022 } | |
| 1023 } | |
| 1024 } | |
| 1025 | |
| 1026 Expression *Expression::inlineScan(InlineScanState *iss) | |
| 1027 { | |
| 1028 return this; | |
| 1029 } | |
| 1030 | |
| 1031 void scanVar(Dsymbol *s, InlineScanState *iss) | |
| 1032 { | |
| 1033 VarDeclaration *vd = s->isVarDeclaration(); | |
| 1034 if (vd) | |
| 1035 { | |
| 1036 TupleDeclaration *td = vd->toAlias()->isTupleDeclaration(); | |
| 1037 if (td) | |
| 1038 { | |
| 1039 for (size_t i = 0; i < td->objects->dim; i++) | |
| 1040 { DsymbolExp *se = (DsymbolExp *)td->objects->data[i]; | |
| 1041 assert(se->op == TOKdsymbol); | |
| 1042 scanVar(se->s, iss); | |
| 1043 } | |
| 1044 } | |
| 1045 else | |
| 1046 { | |
| 1047 // Scan initializer (vd->init) | |
| 1048 if (vd->init) | |
| 1049 { | |
| 1050 ExpInitializer *ie = vd->init->isExpInitializer(); | |
| 1051 | |
| 1052 if (ie) | |
| 1053 { | |
| 1054 ie->exp = ie->exp->inlineScan(iss); | |
| 1055 } | |
| 1056 } | |
| 1057 } | |
| 1058 } | |
| 1059 } | |
| 1060 | |
| 1061 Expression *DeclarationExp::inlineScan(InlineScanState *iss) | |
| 1062 { | |
| 1063 //printf("DeclarationExp::inlineScan()\n"); | |
| 1064 scanVar(declaration, iss); | |
| 1065 return this; | |
| 1066 } | |
| 1067 | |
| 1068 Expression *UnaExp::inlineScan(InlineScanState *iss) | |
| 1069 { | |
| 1070 e1 = e1->inlineScan(iss); | |
| 1071 return this; | |
| 1072 } | |
| 1073 | |
| 1074 Expression *AssertExp::inlineScan(InlineScanState *iss) | |
| 1075 { | |
| 1076 e1 = e1->inlineScan(iss); | |
| 1077 if (msg) | |
| 1078 msg = msg->inlineScan(iss); | |
| 1079 return this; | |
| 1080 } | |
| 1081 | |
| 1082 Expression *BinExp::inlineScan(InlineScanState *iss) | |
| 1083 { | |
| 1084 e1 = e1->inlineScan(iss); | |
| 1085 e2 = e2->inlineScan(iss); | |
| 1086 return this; | |
| 1087 } | |
| 1088 | |
| 1089 | |
| 1090 Expression *CallExp::inlineScan(InlineScanState *iss) | |
| 1091 { Expression *e = this; | |
| 1092 | |
| 1093 //printf("CallExp::inlineScan()\n"); | |
| 1094 e1 = e1->inlineScan(iss); | |
| 1095 arrayInlineScan(iss, arguments); | |
| 1096 | |
| 1097 if (e1->op == TOKvar) | |
| 1098 { | |
| 1099 VarExp *ve = (VarExp *)e1; | |
| 1100 FuncDeclaration *fd = ve->var->isFuncDeclaration(); | |
| 1101 | |
| 1102 if (fd && fd != iss->fd && fd->canInline(0)) | |
| 1103 { | |
| 1104 e = fd->doInline(iss, NULL, arguments); | |
| 1105 } | |
| 1106 } | |
| 1107 else if (e1->op == TOKdotvar) | |
| 1108 { | |
| 1109 DotVarExp *dve = (DotVarExp *)e1; | |
| 1110 FuncDeclaration *fd = dve->var->isFuncDeclaration(); | |
| 1111 | |
| 1112 if (fd && fd != iss->fd && fd->canInline(1)) | |
| 1113 { | |
| 1114 if (dve->e1->op == TOKcall && | |
| 1115 dve->e1->type->toBasetype()->ty == Tstruct) | |
| 1116 { | |
| 1117 /* To create ethis, we'll need to take the address | |
| 1118 * of dve->e1, but this won't work if dve->e1 is | |
| 1119 * a function call. | |
| 1120 */ | |
| 1121 ; | |
| 1122 } | |
| 1123 else | |
| 1124 e = fd->doInline(iss, dve->e1, arguments); | |
| 1125 } | |
| 1126 } | |
| 1127 | |
| 1128 return e; | |
| 1129 } | |
| 1130 | |
| 1131 | |
| 1132 Expression *SliceExp::inlineScan(InlineScanState *iss) | |
| 1133 { | |
| 1134 e1 = e1->inlineScan(iss); | |
| 1135 if (lwr) | |
| 1136 lwr = lwr->inlineScan(iss); | |
| 1137 if (upr) | |
| 1138 upr = upr->inlineScan(iss); | |
| 1139 return this; | |
| 1140 } | |
| 1141 | |
| 1142 | |
| 1143 Expression *TupleExp::inlineScan(InlineScanState *iss) | |
| 1144 { Expression *e = this; | |
| 1145 | |
| 1146 //printf("TupleExp::inlineScan()\n"); | |
| 1147 arrayInlineScan(iss, exps); | |
| 1148 | |
| 1149 return e; | |
| 1150 } | |
| 1151 | |
| 1152 | |
| 1153 Expression *ArrayLiteralExp::inlineScan(InlineScanState *iss) | |
| 1154 { Expression *e = this; | |
| 1155 | |
| 1156 //printf("ArrayLiteralExp::inlineScan()\n"); | |
| 1157 arrayInlineScan(iss, elements); | |
| 1158 | |
| 1159 return e; | |
| 1160 } | |
| 1161 | |
| 1162 | |
| 1163 Expression *AssocArrayLiteralExp::inlineScan(InlineScanState *iss) | |
| 1164 { Expression *e = this; | |
| 1165 | |
| 1166 //printf("AssocArrayLiteralExp::inlineScan()\n"); | |
| 1167 arrayInlineScan(iss, keys); | |
| 1168 arrayInlineScan(iss, values); | |
| 1169 | |
| 1170 return e; | |
| 1171 } | |
| 1172 | |
| 1173 | |
| 1174 Expression *StructLiteralExp::inlineScan(InlineScanState *iss) | |
| 1175 { Expression *e = this; | |
| 1176 | |
| 1177 //printf("StructLiteralExp::inlineScan()\n"); | |
| 1178 arrayInlineScan(iss, elements); | |
| 1179 | |
| 1180 return e; | |
| 1181 } | |
| 1182 | |
| 1183 | |
| 1184 Expression *ArrayExp::inlineScan(InlineScanState *iss) | |
| 1185 { Expression *e = this; | |
| 1186 | |
| 1187 //printf("ArrayExp::inlineScan()\n"); | |
| 1188 e1 = e1->inlineScan(iss); | |
| 1189 arrayInlineScan(iss, arguments); | |
| 1190 | |
| 1191 return e; | |
| 1192 } | |
| 1193 | |
| 1194 | |
| 1195 Expression *CondExp::inlineScan(InlineScanState *iss) | |
| 1196 { | |
| 1197 econd = econd->inlineScan(iss); | |
| 1198 e1 = e1->inlineScan(iss); | |
| 1199 e2 = e2->inlineScan(iss); | |
| 1200 return this; | |
| 1201 } | |
| 1202 | |
| 1203 | |
| 1204 /* ========== =============== */ | |
| 1205 | |
| 1206 void FuncDeclaration::inlineScan() | |
| 1207 { | |
| 1208 InlineScanState iss; | |
| 1209 | |
| 1210 #if LOG | |
| 1211 printf("FuncDeclaration::inlineScan('%s')\n", toChars()); | |
| 1212 #endif | |
| 1213 memset(&iss, 0, sizeof(iss)); | |
| 1214 iss.fd = this; | |
| 1215 if (fbody) | |
| 1216 { | |
| 1217 inlineNest++; | |
| 1218 fbody = fbody->inlineScan(&iss); | |
| 1219 inlineNest--; | |
| 1220 } | |
| 1221 } | |
| 1222 | |
| 1223 int FuncDeclaration::canInline(int hasthis, int hdrscan) | |
| 1224 { | |
| 1225 InlineCostState ics; | |
| 1226 int cost; | |
| 1227 | |
| 1228 #define CANINLINE_LOG 0 | |
| 1229 | |
| 1230 #if CANINLINE_LOG | |
| 1231 printf("FuncDeclaration::canInline(hasthis = %d, '%s')\n", hasthis, toChars()); | |
| 1232 #endif | |
| 1233 | |
| 1234 if (needThis() && !hasthis) | |
| 1235 return 0; | |
| 1236 | |
| 1237 if (inlineNest || (!semanticRun && !hdrscan)) | |
| 1238 { | |
| 1239 #if CANINLINE_LOG | |
| 1240 printf("\t1: no, inlineNest = %d, semanticRun = %d\n", inlineNest, semanticRun); | |
| 1241 #endif | |
| 1242 return 0; | |
| 1243 } | |
| 1244 | |
| 1245 switch (inlineStatus) | |
| 1246 { | |
| 1247 case ILSyes: | |
| 1248 #if CANINLINE_LOG | |
| 1249 printf("\tyes\n"); | |
| 1250 #endif | |
| 1251 return 1; | |
| 1252 | |
| 1253 case ILSno: | |
| 1254 #if CANINLINE_LOG | |
| 1255 printf("\t2: no\n"); | |
| 1256 #endif | |
| 1257 return 0; | |
| 1258 | |
| 1259 case ILSuninitialized: | |
| 1260 break; | |
| 1261 | |
| 1262 default: | |
| 1263 assert(0); | |
| 1264 } | |
| 1265 | |
| 1266 if (type) | |
| 1267 { assert(type->ty == Tfunction); | |
| 1268 TypeFunction *tf = (TypeFunction *)(type); | |
| 1269 if (tf->varargs == 1) // no variadic parameter lists | |
| 1270 goto Lno; | |
| 1271 | |
| 1272 /* Don't inline a function that returns non-void, but has | |
| 1273 * no return expression. | |
| 1274 */ | |
| 1275 if (tf->next && tf->next->ty != Tvoid && | |
| 1276 !(hasReturnExp & 1) && | |
| 1277 !hdrscan) | |
| 1278 goto Lno; | |
| 1279 } | |
| 1280 else | |
| 1281 { CtorDeclaration *ctor = isCtorDeclaration(); | |
| 1282 | |
| 1283 if (ctor && ctor->varargs == 1) | |
| 1284 goto Lno; | |
| 1285 } | |
| 1286 | |
| 1287 if ( | |
| 1288 !fbody || | |
| 1289 !hdrscan && | |
| 1290 ( | |
| 1291 #if 0 | |
| 1292 isCtorDeclaration() || // cannot because need to convert: | |
| 1293 // return; | |
| 1294 // to: | |
| 1295 // return this; | |
| 1296 #endif | |
| 1297 isSynchronized() || | |
| 1298 isImportedSymbol() || | |
| 336 | 1299 #if DMDV2 |
| 92 | 1300 closureVars.dim || // no nested references to this frame |
| 1301 #else | |
| 1 | 1302 nestedFrameRef || // no nested references to this frame |
| 92 | 1303 #endif |
| 1 | 1304 (isVirtual() && !isFinal()) |
| 1305 )) | |
| 1306 { | |
| 1307 goto Lno; | |
| 1308 } | |
| 1309 | |
| 1310 /* If any parameters are Tsarray's (which are passed by reference) | |
| 1311 * or out parameters (also passed by reference), don't do inlining. | |
| 1312 */ | |
| 1313 if (parameters) | |
| 1314 { | |
| 1315 for (int i = 0; i < parameters->dim; i++) | |
| 1316 { | |
| 1317 VarDeclaration *v = (VarDeclaration *)parameters->data[i]; | |
| 1318 if (v->isOut() || v->isRef() || v->type->toBasetype()->ty == Tsarray) | |
| 1319 goto Lno; | |
| 1320 } | |
| 1321 } | |
| 1322 | |
| 1323 memset(&ics, 0, sizeof(ics)); | |
| 1324 ics.hasthis = hasthis; | |
| 1325 ics.fd = this; | |
| 1326 ics.hdrscan = hdrscan; | |
| 1327 cost = fbody->inlineCost(&ics); | |
| 1328 #if CANINLINE_LOG | |
| 1329 printf("cost = %d\n", cost); | |
| 1330 #endif | |
| 1331 if (cost >= COST_MAX) | |
| 1332 goto Lno; | |
| 1333 | |
| 1334 if (!hdrscan) // Don't scan recursively for header content scan | |
| 1335 inlineScan(); | |
| 1336 | |
| 1337 Lyes: | |
| 1338 if (!hdrscan) // Don't modify inlineStatus for header content scan | |
| 1339 inlineStatus = ILSyes; | |
| 1340 #if CANINLINE_LOG | |
| 1341 printf("\tyes\n"); | |
| 1342 #endif | |
| 1343 return 1; | |
| 1344 | |
| 1345 Lno: | |
| 1346 if (!hdrscan) // Don't modify inlineStatus for header content scan | |
| 1347 inlineStatus = ILSno; | |
| 1348 #if CANINLINE_LOG | |
| 1349 printf("\tno\n"); | |
| 1350 #endif | |
| 1351 return 0; | |
| 1352 } | |
| 1353 | |
| 1354 Expression *FuncDeclaration::doInline(InlineScanState *iss, Expression *ethis, Array *arguments) | |
| 1355 { | |
| 1356 InlineDoState ids; | |
| 1357 DeclarationExp *de; | |
| 1358 Expression *e = NULL; | |
| 1359 | |
| 1360 #if LOG | |
| 1361 printf("FuncDeclaration::doInline('%s')\n", toChars()); | |
| 1362 #endif | |
| 1363 | |
| 1364 memset(&ids, 0, sizeof(ids)); | |
| 1365 ids.parent = iss->fd; | |
| 1366 | |
| 1367 // Set up vthis | |
| 1368 if (ethis) | |
| 1369 { | |
| 1370 VarDeclaration *vthis; | |
| 1371 ExpInitializer *ei; | |
| 1372 VarExp *ve; | |
| 1373 | |
| 1374 if (ethis->type->ty != Tclass && ethis->type->ty != Tpointer) | |
| 1375 { | |
| 1376 ethis = ethis->addressOf(NULL); | |
| 1377 } | |
| 1378 | |
| 1379 ei = new ExpInitializer(ethis->loc, ethis); | |
| 1380 | |
| 1381 vthis = new VarDeclaration(ethis->loc, ethis->type, Id::This, ei); | |
| 1382 vthis->storage_class = STCin; | |
| 1383 vthis->linkage = LINKd; | |
| 1384 vthis->parent = iss->fd; | |
| 1385 | |
| 1386 ve = new VarExp(vthis->loc, vthis); | |
| 1387 ve->type = vthis->type; | |
| 1388 | |
| 1389 ei->exp = new AssignExp(vthis->loc, ve, ethis); | |
| 1390 ei->exp->type = ve->type; | |
| 1391 | |
| 1392 ids.vthis = vthis; | |
| 1393 } | |
| 1394 | |
| 1395 // Set up parameters | |
| 1396 if (ethis) | |
| 1397 { | |
| 1398 e = new DeclarationExp(0, ids.vthis); | |
| 1399 e->type = Type::tvoid; | |
| 1400 } | |
| 1401 | |
| 1402 if (arguments && arguments->dim) | |
| 1403 { | |
| 1404 assert(parameters->dim == arguments->dim); | |
| 1405 | |
| 1406 for (int i = 0; i < arguments->dim; i++) | |
| 1407 { | |
| 1408 VarDeclaration *vfrom = (VarDeclaration *)parameters->data[i]; | |
| 1409 VarDeclaration *vto; | |
| 1410 Expression *arg = (Expression *)arguments->data[i]; | |
| 1411 ExpInitializer *ei; | |
| 1412 VarExp *ve; | |
| 1413 | |
| 1414 ei = new ExpInitializer(arg->loc, arg); | |
| 1415 | |
| 1416 vto = new VarDeclaration(vfrom->loc, vfrom->type, vfrom->ident, ei); | |
| 1417 vto->storage_class |= vfrom->storage_class & (STCin | STCout | STClazy | STCref); | |
| 1418 vto->linkage = vfrom->linkage; | |
| 1419 vto->parent = iss->fd; | |
| 1420 //printf("vto = '%s', vto->storage_class = x%x\n", vto->toChars(), vto->storage_class); | |
| 1421 //printf("vto->parent = '%s'\n", iss->fd->toChars()); | |
| 1422 | |
| 1423 ve = new VarExp(vto->loc, vto); | |
| 1424 //ve->type = vto->type; | |
| 1425 ve->type = arg->type; | |
| 1426 | |
| 1427 ei->exp = new AssignExp(vto->loc, ve, arg); | |
| 1428 ei->exp->type = ve->type; | |
| 1429 //ve->type->print(); | |
| 1430 //arg->type->print(); | |
| 1431 //ei->exp->print(); | |
| 1432 | |
| 1433 ids.from.push(vfrom); | |
| 1434 ids.to.push(vto); | |
| 1435 | |
| 1436 de = new DeclarationExp(0, vto); | |
| 1437 de->type = Type::tvoid; | |
| 1438 | |
| 1439 e = Expression::combine(e, de); | |
| 1440 } | |
| 1441 } | |
| 1442 | |
| 1443 inlineNest++; | |
| 1444 Expression *eb = fbody->doInline(&ids); | |
| 1445 inlineNest--; | |
| 1446 //eb->type->print(); | |
| 1447 //eb->print(); | |
| 1448 //eb->dump(0); | |
| 1449 return Expression::combine(e, eb); | |
| 1450 } | |
| 1451 | |
| 1452 | |
| 1453 |