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