| /** |
| * Checks that a function marked `@nogc` does not invoke the Garbage Collector. |
| * |
| * Specification: $(LINK2 https://dlang.org/spec/function.html#nogc-functions, No-GC Functions) |
| * |
| * Copyright: Copyright (C) 1999-2023 by The D Language Foundation, All Rights Reserved |
| * Authors: $(LINK2 https://www.digitalmars.com, Walter Bright) |
| * License: $(LINK2 https://www.boost.org/LICENSE_1_0.txt, Boost License 1.0) |
| * Source: $(LINK2 https://github.com/dlang/dmd/blob/master/src/dmd/nogc.d, _nogc.d) |
| * Documentation: https://dlang.org/phobos/dmd_nogc.html |
| * Coverage: https://codecov.io/gh/dlang/dmd/src/master/src/dmd/nogc.d |
| */ |
| |
| module dmd.nogc; |
| |
| import core.stdc.stdio; |
| |
| import dmd.aggregate; |
| import dmd.apply; |
| import dmd.astenums; |
| import dmd.declaration; |
| import dmd.dscope; |
| import dmd.errors; |
| import dmd.expression; |
| import dmd.func; |
| import dmd.globals; |
| import dmd.init; |
| import dmd.mtype; |
| import dmd.tokens; |
| import dmd.visitor; |
| |
| /************************************** |
| * Look for GC-allocations |
| */ |
| extern (C++) final class NOGCVisitor : StoppableVisitor |
| { |
| alias visit = typeof(super).visit; |
| public: |
| FuncDeclaration f; |
| bool checkOnly; // don't print errors |
| bool err; |
| |
| extern (D) this(FuncDeclaration f) scope |
| { |
| this.f = f; |
| } |
| |
| void doCond(Expression exp) |
| { |
| if (exp) |
| walkPostorder(exp, this); |
| } |
| |
| override void visit(Expression e) |
| { |
| } |
| |
| override void visit(DeclarationExp e) |
| { |
| // Note that, walkPostorder does not support DeclarationExp today. |
| VarDeclaration v = e.declaration.isVarDeclaration(); |
| if (v && !(v.storage_class & STC.manifest) && !v.isDataseg() && v._init) |
| { |
| if (ExpInitializer ei = v._init.isExpInitializer()) |
| { |
| doCond(ei.exp); |
| } |
| } |
| } |
| |
| /** |
| * Register that expression `e` requires the GC |
| * Params: |
| * e = expression that uses GC |
| * format = error message when `e` is used in a `@nogc` function. |
| * Must contain format strings "`@nogc` %s `%s`" referring to the function. |
| * Returns: `true` if `err` was set, `false` if it's not in a `@nogc` and not checkonly (-betterC) |
| */ |
| private bool setGC(Expression e, const(char)* format) |
| { |
| if (checkOnly) |
| { |
| err = true; |
| return true; |
| } |
| if (f.setGC()) |
| { |
| e.error(format, f.kind(), f.toPrettyChars()); |
| err = true; |
| return true; |
| } |
| return false; |
| } |
| |
| override void visit(CallExp e) |
| { |
| import dmd.id : Id; |
| import core.stdc.stdio : printf; |
| if (!e.f) |
| return; |
| |
| // Treat lowered hook calls as their original expressions. |
| auto fd = stripHookTraceImpl(e.f); |
| if (fd.ident == Id._d_arraysetlengthT) |
| { |
| if (setGC(e, "setting `length` in `@nogc` %s `%s` may cause a GC allocation")) |
| return; |
| f.printGCUsage(e.loc, "setting `length` may cause a GC allocation"); |
| } |
| else if (fd.ident == Id._d_arrayappendT || fd.ident == Id._d_arrayappendcTX) |
| { |
| if (setGC(e, "cannot use operator `~=` in `@nogc` %s `%s`")) |
| return; |
| f.printGCUsage(e.loc, "operator `~=` may cause a GC allocation"); |
| } |
| } |
| |
| override void visit(ArrayLiteralExp e) |
| { |
| if (e.type.ty != Tarray || !e.elements || !e.elements.length || e.onstack) |
| return; |
| if (setGC(e, "array literal in `@nogc` %s `%s` may cause a GC allocation")) |
| return; |
| f.printGCUsage(e.loc, "array literal may cause a GC allocation"); |
| } |
| |
| override void visit(AssocArrayLiteralExp e) |
| { |
| if (!e.keys.length) |
| return; |
| if (setGC(e, "associative array literal in `@nogc` %s `%s` may cause a GC allocation")) |
| return; |
| f.printGCUsage(e.loc, "associative array literal may cause a GC allocation"); |
| } |
| |
| override void visit(NewExp e) |
| { |
| if (e.member && !e.member.isNogc() && f.setGC()) |
| { |
| // @nogc-ness is already checked in NewExp::semantic |
| return; |
| } |
| if (e.onstack) |
| return; |
| if (global.params.ehnogc && e.thrownew) |
| return; // separate allocator is called for this, not the GC |
| |
| if (setGC(e, "cannot use `new` in `@nogc` %s `%s`")) |
| return; |
| f.printGCUsage(e.loc, "`new` causes a GC allocation"); |
| } |
| |
| override void visit(DeleteExp e) |
| { |
| if (VarExp ve = e.e1.isVarExp()) |
| { |
| VarDeclaration v = ve.var.isVarDeclaration(); |
| if (v && v.onstack) |
| return; // delete for scope allocated class object |
| } |
| |
| // Semantic should have already handled this case. |
| assert(0); |
| } |
| |
| override void visit(IndexExp e) |
| { |
| Type t1b = e.e1.type.toBasetype(); |
| if (e.modifiable && t1b.ty == Taarray) |
| { |
| if (setGC(e, "assigning an associative array element in `@nogc` %s `%s` may cause a GC allocation")) |
| return; |
| f.printGCUsage(e.loc, "assigning an associative array element may cause a GC allocation"); |
| } |
| } |
| |
| override void visit(AssignExp e) |
| { |
| if (e.e1.op == EXP.arrayLength) |
| { |
| if (setGC(e, "setting `length` in `@nogc` %s `%s` may cause a GC allocation")) |
| return; |
| f.printGCUsage(e.loc, "setting `length` may cause a GC allocation"); |
| } |
| } |
| |
| override void visit(CatAssignExp e) |
| { |
| /* CatAssignExp will exist in `__traits(compiles, ...)` and in the `.e1` branch of a `__ctfe ? :` CondExp. |
| * The other branch will be `_d_arrayappendcTX(e1, 1), e1[$-1]=e2` which will generate the warning about |
| * GC usage. See visit(CallExp). |
| */ |
| if (checkOnly) |
| { |
| err = true; |
| return; |
| } |
| if (f.setGC()) |
| { |
| err = true; |
| return; |
| } |
| } |
| |
| override void visit(CatExp e) |
| { |
| if (setGC(e, "cannot use operator `~` in `@nogc` %s `%s`")) |
| return; |
| f.printGCUsage(e.loc, "operator `~` may cause a GC allocation"); |
| } |
| } |
| |
| Expression checkGC(Scope* sc, Expression e) |
| { |
| if (sc.flags & SCOPE.ctfeBlock) // ignore GC in ctfe blocks |
| return e; |
| |
| /* If betterC, allow GC to happen in non-CTFE code. |
| * Just don't generate code for it. |
| * Detect non-CTFE use of the GC in betterC code. |
| */ |
| const betterC = global.params.betterC; |
| FuncDeclaration f = sc.func; |
| if (e && e.op != EXP.error && f && sc.intypeof != 1 && |
| (!(sc.flags & SCOPE.ctfe) || betterC) && |
| (f.type.ty == Tfunction && |
| (cast(TypeFunction)f.type).isnogc || f.nogcInprocess || global.params.vgc) && |
| !(sc.flags & SCOPE.debug_)) |
| { |
| scope NOGCVisitor gcv = new NOGCVisitor(f); |
| gcv.checkOnly = betterC; |
| walkPostorder(e, gcv); |
| if (gcv.err) |
| { |
| if (betterC) |
| { |
| /* Allow ctfe to use the gc code, but don't let it into the runtime |
| */ |
| f.skipCodegen = true; |
| } |
| else |
| return ErrorExp.get(); |
| } |
| } |
| return e; |
| } |
| |
| /** |
| * Removes `_d_HookTraceImpl` if found from `fd`. |
| * This is needed to be able to find hooks that are called though the hook's `*Trace` wrapper. |
| * Parameters: |
| * fd = The function declaration to remove `_d_HookTraceImpl` from |
| */ |
| private FuncDeclaration stripHookTraceImpl(FuncDeclaration fd) |
| { |
| import dmd.id : Id; |
| import dmd.dsymbol : Dsymbol; |
| import dmd.root.rootobject : RootObject, DYNCAST; |
| |
| if (fd.ident != Id._d_HookTraceImpl) |
| return fd; |
| |
| // Get the Hook from the second template parameter |
| auto templateInstance = fd.parent.isTemplateInstance; |
| RootObject hook = (*templateInstance.tiargs)[1]; |
| assert(hook.dyncast() == DYNCAST.dsymbol, "Expected _d_HookTraceImpl's second template parameter to be an alias to the hook!"); |
| return (cast(Dsymbol)hook).isFuncDeclaration; |
| } |