Mercurial > projects > ddmd
annotate dmd/ReturnStatement.d @ 114:e28b18c23469
added a module dmd.common for commonly used stuff
it currently holds code for consistency checking of predefined versions
also added a VisualD project file
| author | Trass3r |
|---|---|
| date | Wed, 01 Sep 2010 18:21:58 +0200 |
| parents | df6d0f967680 |
| children | af1bebfd96a4 |
| rev | line source |
|---|---|
| 0 | 1 module dmd.ReturnStatement; |
| 2 | |
| 114 | 3 import dmd.common; |
| 0 | 4 import dmd.Loc; |
| 5 import dmd.Statement; | |
| 6 import dmd.GotoStatement; | |
| 7 import dmd.STC; | |
| 8 import dmd.CompoundStatement; | |
| 9 import dmd.Id; | |
| 10 import dmd.AssignExp; | |
| 11 import dmd.ExpStatement; | |
| 12 import dmd.FuncDeclaration; | |
| 13 import dmd.IntegerExp; | |
| 14 import dmd.ThisExp; | |
| 15 import dmd.StructDeclaration; | |
| 16 import dmd.TypeFunction; | |
| 17 import dmd.CSX; | |
| 18 import dmd.RET; | |
| 19 import dmd.TOK; | |
| 20 import dmd.Type; | |
| 21 import dmd.Expression; | |
| 22 import dmd.StructLiteralExp; | |
| 23 import dmd.TypeStruct; | |
| 24 import dmd.Scope; | |
| 25 import dmd.OutBuffer; | |
| 26 import dmd.HdrGenState; | |
| 27 import dmd.InterState; | |
| 28 import dmd.InlineCostState; | |
| 29 import dmd.InlineDoState; | |
| 30 import dmd.InlineScanState; | |
| 31 import dmd.IRState; | |
| 32 import dmd.TY; | |
| 33 import dmd.WANT; | |
| 34 import dmd.VarExp; | |
| 35 import dmd.VarDeclaration; | |
| 63 | 36 import dmd.GlobalExpressions; |
| 0 | 37 import dmd.BE; |
| 67 | 38 |
| 0 | 39 import dmd.codegen.Util; |
| 40 | |
| 41 import dmd.backend.Blockx; | |
| 42 import dmd.backend.elem; | |
| 43 import dmd.backend.TYM; | |
| 44 import dmd.backend.Util; | |
| 45 import dmd.backend.OPER; | |
| 46 import dmd.backend.mTY; | |
| 47 import dmd.backend.BC; | |
| 48 | |
| 67 | 49 import core.stdc.string; |
| 50 | |
| 0 | 51 class ReturnStatement : Statement |
| 52 { | |
| 53 Expression exp; | |
| 54 | |
| 55 this(Loc loc, Expression exp) | |
| 56 { | |
| 57 super(loc); | |
| 58 this.exp = exp; | |
| 59 } | |
| 60 | |
| 72 | 61 override Statement syntaxCopy() |
| 0 | 62 { |
| 63 Expression e = exp ? exp.syntaxCopy() : null; | |
| 64 return new ReturnStatement(loc, e); | |
| 65 } | |
| 66 | |
|
93
df6d0f967680
implemented a whole bunch of methods to make phobos 2.035 compile
Trass3r
parents:
79
diff
changeset
|
67 override void toCBuffer(OutBuffer buf, HdrGenState* hgs) |
| 0 | 68 { |
|
93
df6d0f967680
implemented a whole bunch of methods to make phobos 2.035 compile
Trass3r
parents:
79
diff
changeset
|
69 buf.printf("return "); |
|
df6d0f967680
implemented a whole bunch of methods to make phobos 2.035 compile
Trass3r
parents:
79
diff
changeset
|
70 if (exp) |
|
df6d0f967680
implemented a whole bunch of methods to make phobos 2.035 compile
Trass3r
parents:
79
diff
changeset
|
71 exp.toCBuffer(buf, hgs); |
|
df6d0f967680
implemented a whole bunch of methods to make phobos 2.035 compile
Trass3r
parents:
79
diff
changeset
|
72 buf.writeByte(';'); |
|
df6d0f967680
implemented a whole bunch of methods to make phobos 2.035 compile
Trass3r
parents:
79
diff
changeset
|
73 buf.writenl(); |
| 0 | 74 } |
| 75 | |
|
93
df6d0f967680
implemented a whole bunch of methods to make phobos 2.035 compile
Trass3r
parents:
79
diff
changeset
|
76 override Statement semantic(Scope sc) |
| 0 | 77 { |
| 78 //printf("ReturnStatement.semantic() %s\n", toChars()); | |
| 79 | |
| 80 FuncDeclaration fd = sc.parent.isFuncDeclaration(); | |
| 81 Scope scx = sc; | |
| 82 int implicit0 = 0; | |
| 83 | |
| 84 if (sc.fes) | |
| 85 { | |
| 86 // Find scope of function foreach is in | |
| 87 for (; 1; scx = scx.enclosing) | |
| 88 { | |
| 89 assert(scx); | |
| 90 if (scx.func !is fd) | |
| 91 { | |
| 92 fd = scx.func; // fd is now function enclosing foreach | |
| 93 break; | |
| 94 } | |
| 95 } | |
| 96 } | |
| 97 | |
| 98 Type tret = fd.type.nextOf(); | |
| 99 if (fd.tintro) { | |
| 100 /* We'll be implicitly casting the return expression to tintro | |
| 101 */ | |
| 102 tret = fd.tintro.nextOf(); | |
| 103 } | |
| 104 | |
| 105 Type tbret = null; | |
| 106 | |
| 107 if (tret) { | |
| 108 tbret = tret.toBasetype(); | |
| 109 } | |
| 110 | |
| 111 // main() returns 0, even if it returns void | |
| 112 if (!exp && (!tbret || tbret.ty == TY.Tvoid) && fd.isMain()) | |
| 113 { | |
| 114 implicit0 = 1; | |
| 115 exp = new IntegerExp(0); | |
| 116 } | |
| 117 | |
| 118 if (sc.incontract || scx.incontract) | |
| 119 error("return statements cannot be in contracts"); | |
| 120 | |
| 121 if (sc.tf || scx.tf) | |
| 122 error("return statements cannot be in finally, scope(exit) or scope(success) bodies"); | |
| 123 | |
| 124 if (fd.isCtorDeclaration()) | |
| 125 { | |
| 126 // Constructors implicitly do: | |
| 127 // return this; | |
| 128 if (exp && exp.op != TOK.TOKthis) { | |
| 129 error("cannot return expression from constructor"); | |
| 130 } | |
| 131 | |
| 132 exp = new ThisExp(Loc(0)); | |
| 133 } | |
| 134 | |
| 135 if (!exp) { | |
| 136 fd.nrvo_can = 0; | |
| 137 } | |
| 138 | |
| 139 if (exp) | |
| 140 { | |
| 141 fd.hasReturnExp |= 1; | |
| 142 | |
| 143 exp = exp.semantic(sc); | |
| 144 exp = resolveProperties(sc, exp); | |
| 145 exp = exp.optimize(WANT.WANTvalue); | |
| 146 | |
| 147 if (fd.nrvo_can && exp.op == TOK.TOKvar) { | |
| 148 VarExp ve = cast(VarExp)exp; | |
| 149 VarDeclaration v = ve.var.isVarDeclaration(); | |
| 150 | |
| 151 if ((cast(TypeFunction)fd.type).isref) { | |
| 152 // Function returns a reference | |
| 153 fd.nrvo_can = 0; | |
| 154 } else if (!v || v.isOut() || v.isRef()) { | |
| 155 fd.nrvo_can = 0; | |
| 156 } else if (tbret.ty == TY.Tstruct && (cast(TypeStruct)tbret).sym.dtor) { | |
| 157 // Struct being returned has destructors | |
| 158 fd.nrvo_can = 0; | |
| 159 } else if (fd.nrvo_var is null) { | |
| 160 if (!v.isDataseg() && !v.isParameter() && v.toParent2() == fd) { | |
| 161 //printf("Setting nrvo to %s\n", v.toChars()); | |
| 162 fd.nrvo_var = v; | |
| 163 } else { | |
| 164 fd.nrvo_can = 0; | |
| 165 } | |
| 166 } else if (fd.nrvo_var != v) { | |
| 167 fd.nrvo_can = 0; | |
| 168 } | |
| 169 } else { | |
| 170 fd.nrvo_can = 0; | |
| 171 } | |
| 172 | |
| 173 if (fd.returnLabel && tbret.ty != TY.Tvoid) { | |
| 174 ; | |
| 175 } else if (fd.inferRetType) { | |
| 176 if (fd.type.nextOf()) { | |
| 177 if (!exp.type.equals(fd.type.nextOf())) | |
| 178 error("mismatched function return type inference of %s and %s", exp.type.toChars(), fd.type.nextOf().toChars()); | |
| 179 } | |
| 180 else | |
| 181 { | |
| 182 (cast(TypeFunction)fd.type).next = exp.type; | |
| 183 fd.type = fd.type.semantic(loc, sc); | |
| 184 if (!fd.tintro) | |
| 185 { | |
| 186 tret = fd.type.nextOf(); | |
| 187 tbret = tret.toBasetype(); | |
| 188 } | |
| 189 } | |
| 190 } else if (tbret.ty != TY.Tvoid) | |
| 191 { | |
| 192 exp = exp.implicitCastTo(sc, tret); | |
| 193 exp = exp.optimize(WANT.WANTvalue); | |
| 194 } | |
| 195 } else if (fd.inferRetType) { | |
| 196 if (fd.type.nextOf()) | |
| 197 { | |
| 198 if (fd.type.nextOf().ty != TY.Tvoid) { | |
| 199 error("mismatched function return type inference of void and %s", fd.type.nextOf().toChars()); | |
| 200 } | |
| 201 } | |
| 202 else | |
| 203 { | |
| 204 (cast(TypeFunction*)fd.type).next = Type.tvoid; | |
| 205 fd.type = fd.type.semantic(loc, sc); | |
| 206 if (!fd.tintro) | |
| 207 { | |
| 208 tret = Type.tvoid; | |
| 209 tbret = tret; | |
| 210 } | |
| 211 } | |
| 212 } | |
| 213 else if (tbret.ty != TY.Tvoid) {// if non-void return | |
| 214 error("return expression expected"); | |
| 215 } | |
| 216 | |
| 217 if (sc.fes) | |
| 218 { | |
| 219 Statement s; | |
| 220 | |
| 221 if (exp && !implicit0) | |
| 222 { | |
| 223 exp = exp.implicitCastTo(sc, tret); | |
| 224 } | |
| 225 if (!exp || exp.op == TOK.TOKint64 || exp.op == TOK.TOKfloat64 || | |
| 226 exp.op == TOK.TOKimaginary80 || exp.op == TOK.TOKcomplex80 || | |
| 227 exp.op == TOK.TOKthis || exp.op == TOK.TOKsuper || exp.op == TOK.TOKnull || | |
| 228 exp.op == TOK.TOKstring) | |
| 229 { | |
| 230 sc.fes.cases.push(cast(void*)this); | |
| 231 // Construct: return cases.dim+1; | |
| 232 s = new ReturnStatement(Loc(0), new IntegerExp(sc.fes.cases.dim + 1)); | |
| 233 } | |
| 234 else if (fd.type.nextOf().toBasetype() == Type.tvoid) | |
| 235 { | |
| 236 s = new ReturnStatement(Loc(0), null); | |
| 237 sc.fes.cases.push(cast(void*)s); | |
| 238 | |
| 239 // Construct: { exp; return cases.dim + 1; } | |
| 240 Statement s1 = new ExpStatement(loc, exp); | |
| 241 Statement s2 = new ReturnStatement(Loc(0), new IntegerExp(sc.fes.cases.dim + 1)); | |
| 242 s = new CompoundStatement(loc, s1, s2); | |
| 243 } | |
| 244 else | |
| 245 { | |
| 246 // Construct: return vresult; | |
| 247 if (!fd.vresult) | |
| 248 { | |
| 249 // Declare vresult | |
| 250 VarDeclaration v = new VarDeclaration(loc, tret, Id.result, null); | |
| 251 v.noauto = true; | |
| 252 v.semantic(scx); | |
| 253 if (!scx.insert(v)) { | |
| 254 assert(0); | |
| 255 } | |
| 256 v.parent = fd; | |
| 257 fd.vresult = v; | |
| 258 } | |
| 259 | |
| 260 s = new ReturnStatement(Loc(0), new VarExp(Loc(0), fd.vresult)); | |
| 261 sc.fes.cases.push(cast(void*)s); | |
| 262 | |
| 263 // Construct: { vresult = exp; return cases.dim + 1; } | |
| 264 exp = new AssignExp(loc, new VarExp(Loc(0), fd.vresult), exp); | |
| 265 exp.op = TOK.TOKconstruct; | |
| 266 exp = exp.semantic(sc); | |
| 267 Statement s1 = new ExpStatement(loc, exp); | |
| 268 Statement s2 = new ReturnStatement(Loc(0), new IntegerExp(sc.fes.cases.dim + 1)); | |
| 269 s = new CompoundStatement(loc, s1, s2); | |
| 270 } | |
| 271 return s; | |
| 272 } | |
| 273 | |
| 274 if (exp) | |
| 275 { | |
| 276 if (fd.returnLabel && tbret.ty != TY.Tvoid) | |
| 277 { | |
| 278 assert(fd.vresult); | |
| 279 VarExp v = new VarExp(Loc(0), fd.vresult); | |
| 280 | |
| 281 exp = new AssignExp(loc, v, exp); | |
| 282 exp.op = TOK.TOKconstruct; | |
| 283 exp = exp.semantic(sc); | |
| 284 } | |
| 285 | |
| 286 if ((cast(TypeFunction)fd.type).isref && !fd.isCtorDeclaration()) | |
| 287 { // Function returns a reference | |
| 288 if (tbret.isMutable()) | |
| 289 exp = exp.modifiableLvalue(sc, exp); | |
| 290 else | |
| 291 exp = exp.toLvalue(sc, exp); | |
| 292 | |
| 293 if (exp.op == TOK.TOKvar) | |
| 294 { | |
| 295 VarExp ve = cast(VarExp)exp; | |
| 296 VarDeclaration v = ve.var.isVarDeclaration(); | |
| 297 if (v && !v.isDataseg() && !(v.storage_class & (STC.STCref | STC.STCout))) { | |
| 298 error("escaping reference to local variable %s", v.toChars()); | |
| 299 } | |
| 300 } | |
| 301 } | |
| 302 | |
| 303 //exp.dump(0); | |
| 304 //exp.print(); | |
| 305 exp.checkEscape(); | |
| 306 } | |
| 307 | |
| 308 /* BUG: need to issue an error on: | |
| 309 * this | |
| 310 * { if (x) return; | |
| 311 * super(); | |
| 312 * } | |
| 313 */ | |
| 314 | |
| 315 if (sc.callSuper & CSX.CSXany_ctor && !(sc.callSuper & (CSX.CSXthis_ctor | CSX.CSXsuper_ctor))) { | |
| 316 error("return without calling constructor"); | |
| 317 } | |
| 318 | |
| 319 sc.callSuper |= CSX.CSXreturn; | |
| 320 | |
| 321 // See if all returns are instead to be replaced with a goto returnLabel; | |
| 322 if (fd.returnLabel) | |
| 323 { | |
| 324 GotoStatement gs = new GotoStatement(loc, Id.returnLabel); | |
| 325 | |
| 326 gs.label = fd.returnLabel; | |
| 327 if (exp) | |
| 328 { | |
| 329 /* Replace: return exp; | |
| 330 * with: exp; goto returnLabel; | |
| 331 */ | |
| 332 Statement s = new ExpStatement(Loc(0), exp); | |
| 333 return new CompoundStatement(loc, s, gs); | |
| 334 } | |
| 335 return gs; | |
| 336 } | |
| 337 | |
| 73 | 338 if (exp && tbret.ty == Tvoid && !implicit0) |
| 0 | 339 { |
| 340 /* Replace: | |
| 341 * return exp; | |
| 342 * with: | |
| 343 * exp; return; | |
| 344 */ | |
| 345 Statement s = new ExpStatement(loc, exp); | |
| 79 | 346 exp = null; |
| 347 s = s.semantic(sc); | |
| 348 loc = Loc(); | |
| 0 | 349 return new CompoundStatement(loc, s, this); |
| 350 } | |
| 351 | |
| 352 return this; | |
| 353 } | |
| 354 | |
| 72 | 355 override BE blockExit() |
| 0 | 356 { |
| 357 BE result = BE.BEreturn; | |
| 358 if (exp && exp.canThrow()) | |
| 359 result |= BE.BEthrow; | |
| 360 | |
| 361 return result; | |
| 362 } | |
| 363 | |
| 72 | 364 override Expression interpret(InterState istate) |
| 0 | 365 { |
| 63 | 366 version (LOG) { |
| 367 printf("ReturnStatement.interpret(%s)\n", exp ? exp.toChars() : ""); | |
| 368 } | |
| 369 mixin(START!()); | |
| 370 if (!exp) | |
| 371 return EXP_VOID_INTERPRET; | |
| 372 version (LOG) { | |
| 373 Expression e = exp.interpret(istate); | |
| 374 printf("e = %p\n", e); | |
| 375 return e; | |
| 376 } else { | |
| 377 return exp.interpret(istate); | |
| 378 } | |
| 0 | 379 } |
| 380 | |
| 72 | 381 override int inlineCost(InlineCostState* ics) |
| 0 | 382 { |
| 383 // Can't handle return statements nested in if's | |
| 384 if (ics.nested) | |
| 385 return COST_MAX; | |
| 386 return exp ? exp.inlineCost(ics) : 0; | |
| 387 } | |
| 388 | |
| 72 | 389 override Expression doInline(InlineDoState ids) |
| 0 | 390 { |
| 391 //printf("ReturnStatement.doInline() '%s'\n", exp ? exp.toChars() : ""); | |
| 392 return exp ? exp.doInline(ids) : null; | |
| 393 } | |
| 394 | |
| 72 | 395 override Statement inlineScan(InlineScanState* iss) |
| 0 | 396 { |
| 397 //printf("ReturnStatement.inlineScan()\n"); | |
| 398 if (exp) | |
| 399 { | |
| 400 exp = exp.inlineScan(iss); | |
| 401 } | |
| 402 return this; | |
| 403 } | |
| 404 | |
| 72 | 405 override void toIR(IRState* irs) |
| 0 | 406 { |
| 407 Blockx* blx = irs.blx; | |
|
68
ee3a9f34dc48
final bits of codegen implementation to compile Phobos
korDen
parents:
67
diff
changeset
|
408 |
| 0 | 409 incUsage(irs, loc); |
| 410 if (exp) | |
| 411 { | |
|
68
ee3a9f34dc48
final bits of codegen implementation to compile Phobos
korDen
parents:
67
diff
changeset
|
412 //printf("%.*s %.*s\n", exp.classinfo.name, exp.toChars()); |
| 0 | 413 elem *e; |
| 414 | |
| 415 FuncDeclaration func = irs.getFunc(); | |
| 416 assert(func); | |
| 417 assert(func.type.ty == TY.Tfunction); | |
| 418 TypeFunction tf = cast(TypeFunction)(func.type); | |
| 419 | |
| 420 RET retmethod = tf.retStyle(); | |
| 421 if (retmethod == RET.RETstack) | |
| 422 { | |
| 423 elem* es; | |
| 424 | |
| 425 /* If returning struct literal, write result | |
| 426 * directly into return value | |
| 427 */ | |
| 428 if (exp.op == TOK.TOKstructliteral) | |
| 429 { | |
|
68
ee3a9f34dc48
final bits of codegen implementation to compile Phobos
korDen
parents:
67
diff
changeset
|
430 StructLiteralExp se = cast(StructLiteralExp)exp; |
| 67 | 431 enum objectSize = __traits(classInstanceSize, StructLiteralExp); |
| 432 ubyte save[objectSize]; | |
| 433 memcpy(save.ptr, cast(void*)se, objectSize); | |
| 0 | 434 se.sym = irs.shidden; |
| 435 se.soffset = 0; | |
| 436 se.fillHoles = 1; | |
| 437 e = exp.toElem(irs); | |
| 67 | 438 memcpy(cast(void*)se, save.ptr, objectSize); |
| 0 | 439 } |
| 440 else | |
| 441 e = exp.toElem(irs); | |
| 442 | |
| 443 assert(e); | |
| 444 | |
| 445 if (exp.op == TOK.TOKstructliteral || (func.nrvo_can && func.nrvo_var)) | |
| 446 { | |
| 447 // Return value via hidden pointer passed as parameter | |
| 448 // Write exp; return shidden; | |
| 449 es = e; | |
| 450 } | |
| 451 else | |
| 452 { | |
| 453 // Return value via hidden pointer passed as parameter | |
| 454 // Write *shidden=exp; return shidden; | |
| 455 int op; | |
| 456 tym_t ety; | |
| 457 | |
| 458 ety = e.Ety; | |
| 459 es = el_una(OPER.OPind,ety,el_var(irs.shidden)); | |
| 460 op = (tybasic(ety) == TYM.TYstruct) ? OPER.OPstreq : OPER.OPeq; | |
| 461 es = el_bin(op, ety, es, e); | |
| 462 if (op == OPER.OPstreq) | |
| 463 es.Enumbytes = cast(uint)exp.type.size(); | |
| 464 version (DMDV2) { | |
| 465 /* Call postBlit() on *shidden | |
| 466 */ | |
| 467 Type tb = exp.type.toBasetype(); | |
| 468 //if (tb.ty == TY.Tstruct) exp.dump(0); | |
| 469 if ((exp.op == TOK.TOKvar || exp.op == TOK.TOKdotvar || exp.op == TOK.TOKstar) && | |
| 470 tb.ty == TY.Tstruct) | |
|
68
ee3a9f34dc48
final bits of codegen implementation to compile Phobos
korDen
parents:
67
diff
changeset
|
471 { |
|
ee3a9f34dc48
final bits of codegen implementation to compile Phobos
korDen
parents:
67
diff
changeset
|
472 StructDeclaration sd = (cast(TypeStruct)tb).sym; |
| 0 | 473 if (sd.postblit) |
| 474 { | |
| 475 FuncDeclaration fd = sd.postblit; | |
| 476 elem* ec = el_var(irs.shidden); | |
| 477 ec = callfunc(loc, irs, 1, Type.tvoid, ec, tb.pointerTo(), fd, fd.type, null, null); | |
| 478 es = el_bin(OPER.OPcomma, ec.Ety, es, ec); | |
| 479 } | |
| 480 | |
| 481 static if (false) { | |
| 482 /* It has been moved, so disable destructor | |
| 483 */ | |
| 484 if (exp.op == TOK.TOKvar) | |
| 485 { | |
| 486 VarExp ve = cast(VarExp)exp; | |
| 487 VarDeclaration v = ve.var.isVarDeclaration(); | |
| 488 if (v && v.rundtor) | |
| 489 { | |
| 490 elem* er = el_var(v.rundtor.toSymbol()); | |
| 491 er = el_bin(OPER.OPeq, TYM.TYint, er, el_long(TYM.TYint, 0)); | |
| 492 es = el_bin(OPER.OPcomma, TYM.TYint, es, er); | |
| 493 } | |
| 494 } | |
| 495 } | |
| 496 } | |
| 497 } | |
| 498 } | |
| 499 e = el_var(irs.shidden); | |
| 500 e = el_bin(OPER.OPcomma, e.Ety, es, e); | |
| 501 } | |
| 502 ///version (DMDV2) { | |
| 503 else if (tf.isref) | |
| 504 { // Reference return, so convert to a pointer | |
| 505 Expression ae = exp.addressOf(null); | |
| 506 e = ae.toElem(irs); | |
| 507 } | |
| 508 ///} | |
| 509 else | |
| 510 { | |
| 511 e = exp.toElem(irs); | |
| 512 assert(e); | |
| 513 } | |
| 514 | |
| 515 block_appendexp(blx.curblock, e); | |
| 516 block_next(blx, BC.BCretexp, null); | |
| 517 } | |
| 518 else | |
| 519 block_next(blx, BC.BCret, null); | |
| 520 } | |
| 521 | |
| 72 | 522 override ReturnStatement isReturnStatement() { return this; } |
| 523 } |