# # # The Nim Compiler # (c) Copyright 2015 Andreas Rumpf # # See the file "copying.txt", included in this # distribution, for details about the copyright. # ## This module implements the C code generator. import ast, astalgo, hashes, trees, platform, magicsys, extccomp, options, intsets, nversion, nimsets, msgs, bitsets, idents, types, ccgutils, os, ropes, math, passes, wordrecg, treetab, cgmeth, rodutils, renderer, cgendata, aliases, lowerings, tables, sets, ndi, lineinfos, pathutils, transf, injectdestructors, astmsgs when not defined(leanCompiler): import spawn, semparallel import strutils except `%` # collides with ropes.`%` from ic / ic import ModuleBackendFlag import dynlib when not declared(dynlib.libCandidates): proc libCandidates(s: string, dest: var seq[string]) = ## given a library name pattern `s` write possible library names to `dest`. var le = strutils.find(s, '(') var ri = strutils.find(s, ')', le+1) if le >= 0 and ri > le: var prefix = substr(s, 0, le - 1) var suffix = substr(s, ri + 1) for middle in split(substr(s, le + 1, ri - 1), '|'): libCandidates(prefix & middle & suffix, dest) else: dest.add(s) when options.hasTinyCBackend: import tccgen proc hcrOn(m: BModule): bool = m.config.hcrOn proc hcrOn(p: BProc): bool = p.module.config.hcrOn proc addForwardedProc(m: BModule, prc: PSym) = m.g.forwardedProcs.add(prc) proc findPendingModule(m: BModule, s: PSym): BModule = let ms = s.itemId.module #getModule(s) result = m.g.modules[ms] proc initLoc(result: var TLoc, k: TLocKind, lode: PNode, s: TStorageLoc) = result.k = k result.storage = s result.lode = lode result.r = nil result.flags = {} proc fillLoc(a: var TLoc, k: TLocKind, lode: PNode, r: Rope, s: TStorageLoc) = # fills the loc if it is not already initialized if a.k == locNone: a.k = k a.lode = lode a.storage = s if a.r == nil: a.r = r proc t(a: TLoc): PType {.inline.} = if a.lode.kind == nkSym: result = a.lode.sym.typ else: result = a.lode.typ proc lodeTyp(t: PType): PNode = result = newNode(nkEmpty) result.typ = t proc isSimpleConst(typ: PType): bool = let t = skipTypes(typ, abstractVar) result = t.kind notin {tyTuple, tyObject, tyArray, tySet, tySequence} and not (t.kind == tyProc and t.callConv == ccClosure) proc useHeader(m: BModule, sym: PSym) = if lfHeader in sym.loc.flags: assert(sym.annex != nil) let str = getStr(sym.annex.path) m.includeHeader(str) proc cgsym(m: BModule, name: string): Rope proc getCFile(m: BModule): AbsoluteFile proc getModuleDllPath(m: BModule): Rope = let (dir, name, ext) = splitFile(getCFile(m)) let filename = strutils.`%`(platform.OS[m.g.config.target.targetOS].dllFrmt, [name & ext]) result = makeCString(dir.string & "/" & filename) proc getModuleDllPath(m: BModule, module: int): Rope = result = getModuleDllPath(m.g.modules[module]) proc getModuleDllPath(m: BModule, s: PSym): Rope = result = getModuleDllPath(m.g.modules[s.itemId.module]) import macros proc cgFormatValue(result: var string; value: Rope) = for str in leaves(value): result.add str proc cgFormatValue(result: var string; value: string) = result.add value proc cgFormatValue(result: var string; value: BiggestInt) = result.addInt value proc cgFormatValue(result: var string; value: Int128) = result.addInt128 value # TODO: please document macro ropecg(m: BModule, frmt: static[FormatStr], args: untyped): Rope = args.expectKind nnkBracket # echo "ropecg ", newLit(frmt).repr, ", ", args.repr var i = 0 result = nnkStmtListExpr.newTree() result.add quote do: assert `m` != nil let resVar = genSym(nskVar, "res") # during `koch boot` the median of all generates strings from this # macro is around 40 bytes in length. result.add newVarStmt(resVar, newCall(bindSym"newStringOfCap", newLit(80))) let formatValue = bindSym"cgFormatValue" var num = 0 var strLit = "" template flushStrLit() = if strLit != "": result.add newCall(ident "add", resVar, newLit(strLit)) strLit.setLen 0 while i < frmt.len: if frmt[i] == '$': inc(i) # skip '$' case frmt[i] of '$': strLit.add '$' inc(i) of '#': flushStrLit() inc(i) result.add newCall(formatValue, resVar, args[num]) inc(num) of '0'..'9': var j = 0 while true: j = (j * 10) + ord(frmt[i]) - ord('0') inc(i) if i >= frmt.len or not (frmt[i] in {'0'..'9'}): break num = j if j > args.len: error("ropes: invalid format string " & newLit(frmt).repr & " args.len: " & $args.len) flushStrLit() result.add newCall(formatValue, resVar, args[j-1]) of 'n': flushStrLit() result.add quote do: if optLineDir notin `m`.config.options: `resVar`.add("\L") inc(i) of 'N': strLit.add "\L" inc(i) else: error("ropes: invalid format string $" & frmt[i]) elif frmt[i] == '#' and frmt[i+1] in IdentStartChars: inc(i) var j = i while frmt[j] in IdentChars: inc(j) var ident = newLit(substr(frmt, i, j-1)) i = j flushStrLit() result.add newCall(formatValue, resVar, newCall(ident"cgsym", m, ident)) elif frmt[i] == '#' and frmt[i+1] == '$': inc(i, 2) var j = 0 while frmt[i] in Digits: j = (j * 10) + ord(frmt[i]) - ord('0') inc(i) let ident = args[j-1] flushStrLit() result.add newCall(formatValue, resVar, newCall(ident"cgsym", m, ident)) var start = i while i < frmt.len: if frmt[i] != '$' and frmt[i] != '#': inc(i) else: break if i - 1 >= start: strLit.add(substr(frmt, start, i - 1)) flushStrLit() result.add newCall(ident"rope", resVar) proc indentLine(p: BProc, r: Rope): Rope = result = r for i in 0..= 0 if optLineDir in conf.options and line > 0: r.addf("$N#line $2 $1$N", [rope(makeSingleLineCString(filename)), rope(line)]) proc genCLineDir(r: var Rope, info: TLineInfo; conf: ConfigRef) = genCLineDir(r, toFullPath(conf, info), info.safeLineNm, conf) proc freshLineInfo(p: BProc; info: TLineInfo): bool = if p.lastLineInfo.line != info.line or p.lastLineInfo.fileIndex != info.fileIndex: p.lastLineInfo.line = info.line p.lastLineInfo.fileIndex = info.fileIndex result = true proc genLineDir(p: BProc, t: PNode) = let line = t.info.safeLineNm if optEmbedOrigSrc in p.config.globalOptions: p.s(cpsStmts).add(~"//" & sourceLine(p.config, t.info) & "\L") genCLineDir(p.s(cpsStmts), toFullPath(p.config, t.info), line, p.config) if ({optLineTrace, optStackTrace} * p.options == {optLineTrace, optStackTrace}) and (p.prc == nil or sfPure notin p.prc.flags) and t.info.fileIndex != InvalidFileIdx: if freshLineInfo(p, t.info): linefmt(p, cpsStmts, "nimln_($1, $2);$n", [line, quotedFilename(p.config, t.info)]) proc postStmtActions(p: BProc) {.inline.} = p.s(cpsStmts).add(p.module.injectStmt) proc accessThreadLocalVar(p: BProc, s: PSym) proc emulatedThreadVars(conf: ConfigRef): bool {.inline.} proc genProc(m: BModule, prc: PSym) proc raiseInstr(p: BProc): Rope template compileToCpp(m: BModule): untyped = m.config.backend == backendCpp or sfCompileToCpp in m.module.flags proc getTempName(m: BModule): Rope = result = m.tmpBase & rope(m.labels) inc m.labels proc rdLoc(a: TLoc): Rope = # 'read' location (deref if indirect) result = a.r if lfIndirect in a.flags: result = "(*$1)" % [result] proc lenField(p: BProc): Rope = result = rope(if p.module.compileToCpp: "len" else: "Sup.len") proc lenExpr(p: BProc; a: TLoc): Rope = if optSeqDestructors in p.config.globalOptions: result = rdLoc(a) & ".len" else: result = "($1 ? $1->$2 : 0)" % [rdLoc(a), lenField(p)] proc dataField(p: BProc): Rope = if optSeqDestructors in p.config.globalOptions: result = rope".p->data" else: result = rope"->data" include ccgliterals include ccgtypes # ------------------------------ Manager of temporaries ------------------ template mapTypeChooser(n: PNode): TSymKind = (if n.kind == nkSym: n.sym.kind else: skVar) template mapTypeChooser(a: TLoc): TSymKind = mapTypeChooser(a.lode) proc addrLoc(conf: ConfigRef; a: TLoc): Rope = result = a.r if lfIndirect notin a.flags and mapType(conf, a.t, mapTypeChooser(a)) != ctArray: result = "(&" & result & ")" proc byRefLoc(p: BProc; a: TLoc): Rope = result = a.r if lfIndirect notin a.flags and mapType(p.config, a.t, mapTypeChooser(a)) != ctArray and not p.module.compileToCpp: result = "(&" & result & ")" proc rdCharLoc(a: TLoc): Rope = # read a location that may need a char-cast: result = rdLoc(a) if skipTypes(a.t, abstractRange).kind == tyChar: result = "((NU8)($1))" % [result] type TAssignmentFlag = enum needToCopy TAssignmentFlags = set[TAssignmentFlag] proc genObjConstr(p: BProc, e: PNode, d: var TLoc) proc rawConstExpr(p: BProc, n: PNode; d: var TLoc) proc genAssignment(p: BProc, dest, src: TLoc, flags: TAssignmentFlags) type ObjConstrMode = enum constructObj, constructRefObj proc genObjectInit(p: BProc, section: TCProcSection, t: PType, a: var TLoc, mode: ObjConstrMode) = #if optNimV2 in p.config.globalOptions: return case analyseObjectWithTypeField(t) of frNone: discard of frHeader: var r = rdLoc(a) if mode == constructRefObj: r = "(*$1)" % [r] var s = skipTypes(t, abstractInst) if not p.module.compileToCpp: while s.kind == tyObject and s[0] != nil: r.add(".Sup") s = skipTypes(s[0], skipPtrs) if optTinyRtti in p.config.globalOptions: linefmt(p, section, "$1.m_type = $2;$n", [r, genTypeInfoV2(p.module, t, a.lode.info)]) else: linefmt(p, section, "$1.m_type = $2;$n", [r, genTypeInfoV1(p.module, t, a.lode.info)]) of frEmbedded: if optTinyRtti in p.config.globalOptions: var tmp: TLoc if mode == constructRefObj: let objType = t.skipTypes(abstractInst+{tyRef}) rawConstExpr(p, newNodeIT(nkType, a.lode.info, objType), tmp) linefmt(p, cpsStmts, "#nimCopyMem((void*)$1, (NIM_CONST void*)&$2, sizeof($3));$n", [rdLoc(a), rdLoc(tmp), getTypeDesc(p.module, objType, mapTypeChooser(a))]) else: rawConstExpr(p, newNodeIT(nkType, a.lode.info, t), tmp) genAssignment(p, a, tmp, {}) else: # worst case for performance: var r = if mode == constructObj: addrLoc(p.config, a) else: rdLoc(a) linefmt(p, section, "#objectInit($1, $2);$n", [r, genTypeInfoV1(p.module, t, a.lode.info)]) if isException(t): var r = rdLoc(a) if mode == constructRefObj: r = "(*$1)" % [r] var s = skipTypes(t, abstractInst) if not p.module.compileToCpp: while s.kind == tyObject and s[0] != nil and s.sym.magic != mException: r.add(".Sup") s = skipTypes(s[0], skipPtrs) linefmt(p, section, "$1.name = $2;$n", [r, makeCString(t.skipTypes(abstractInst).sym.name.s)]) proc genRefAssign(p: BProc, dest, src: TLoc) proc isComplexValueType(t: PType): bool {.inline.} = let t = t.skipTypes(abstractInst + tyUserTypeClasses) result = t.kind in {tyArray, tySet, tyTuple, tyObject, tyOpenArray} or (t.kind == tyProc and t.callConv == ccClosure) include ccgreset proc resetLoc(p: BProc, loc: var TLoc) = let containsGcRef = optSeqDestructors notin p.config.globalOptions and containsGarbageCollectedRef(loc.t) let typ = skipTypes(loc.t, abstractVarRange) if isImportedCppType(typ): return if optSeqDestructors in p.config.globalOptions and typ.kind in {tyString, tySequence}: assert rdLoc(loc) != nil let atyp = skipTypes(loc.t, abstractInst) if atyp.kind in {tyVar, tyLent}: linefmt(p, cpsStmts, "$1->len = 0; $1->p = NIM_NIL;$n", [rdLoc(loc)]) else: linefmt(p, cpsStmts, "$1.len = 0; $1.p = NIM_NIL;$n", [rdLoc(loc)]) elif not isComplexValueType(typ): if containsGcRef: var nilLoc: TLoc initLoc(nilLoc, locTemp, loc.lode, OnStack) nilLoc.r = rope("NIM_NIL") genRefAssign(p, loc, nilLoc) else: linefmt(p, cpsStmts, "$1 = 0;$n", [rdLoc(loc)]) else: if loc.storage != OnStack and containsGcRef: specializeReset(p, loc) when false: linefmt(p, cpsStmts, "#genericReset((void*)$1, $2);$n", [addrLoc(p.config, loc), genTypeInfoV1(p.module, loc.t, loc.lode.info)]) # XXX: generated reset procs should not touch the m_type # field, so disabling this should be safe: genObjectInit(p, cpsStmts, loc.t, loc, constructObj) else: # array passed as argument decayed into pointer, bug #7332 # so we use getTypeDesc here rather than rdLoc(loc) linefmt(p, cpsStmts, "#nimZeroMem((void*)$1, sizeof($2));$n", [addrLoc(p.config, loc), getTypeDesc(p.module, loc.t, mapTypeChooser(loc))]) # XXX: We can be extra clever here and call memset only # on the bytes following the m_type field? genObjectInit(p, cpsStmts, loc.t, loc, constructObj) proc constructLoc(p: BProc, loc: var TLoc, isTemp = false) = let typ = loc.t if optSeqDestructors in p.config.globalOptions and skipTypes(typ, abstractInst + {tyStatic}).kind in {tyString, tySequence}: linefmt(p, cpsStmts, "$1.len = 0; $1.p = NIM_NIL;$n", [rdLoc(loc)]) elif not isComplexValueType(typ): linefmt(p, cpsStmts, "$1 = ($2)0;$n", [rdLoc(loc), getTypeDesc(p.module, typ, mapTypeChooser(loc))]) else: if not isTemp or containsGarbageCollectedRef(loc.t): # don't use nimZeroMem for temporary values for performance if we can # avoid it: if not isImportedCppType(typ): linefmt(p, cpsStmts, "#nimZeroMem((void*)$1, sizeof($2));$n", [addrLoc(p.config, loc), getTypeDesc(p.module, typ, mapTypeChooser(loc))]) genObjectInit(p, cpsStmts, loc.t, loc, constructObj) proc initLocalVar(p: BProc, v: PSym, immediateAsgn: bool) = if sfNoInit notin v.flags: # we know it is a local variable and thus on the stack! # If ``not immediateAsgn`` it is not initialized in a binding like # ``var v = X`` and thus we need to init it. # If ``v`` contains a GC-ref we may pass it to ``unsureAsgnRef`` somehow # which requires initialization. However this can really only happen if # ``var v = X()`` gets transformed into ``X(&v)``. # Nowadays the logic in ccgcalls deals with this case however. if not immediateAsgn: constructLoc(p, v.loc) proc getTemp(p: BProc, t: PType, result: var TLoc; needsInit=false) = inc(p.labels) result.r = "T" & rope(p.labels) & "_" linefmt(p, cpsLocals, "$1 $2;$n", [getTypeDesc(p.module, t, skVar), result.r]) result.k = locTemp result.lode = lodeTyp t result.storage = OnStack result.flags = {} constructLoc(p, result, not needsInit) when false: # XXX Introduce a compiler switch in order to detect these easily. if getSize(p.config, t) > 1024 * 1024: if p.prc != nil: echo "ENORMOUS TEMPORARY! ", p.config $ p.prc.info else: echo "ENORMOUS TEMPORARY! ", p.config $ p.lastLineInfo writeStackTrace() proc getTempCpp(p: BProc, t: PType, result: var TLoc; value: Rope) = inc(p.labels) result.r = "T" & rope(p.labels) & "_" linefmt(p, cpsStmts, "$1 $2 = $3;$n", [getTypeDesc(p.module, t, skVar), result.r, value]) result.k = locTemp result.lode = lodeTyp t result.storage = OnStack result.flags = {} proc getIntTemp(p: BProc, result: var TLoc) = inc(p.labels) result.r = "T" & rope(p.labels) & "_" linefmt(p, cpsLocals, "NI $1;$n", [result.r]) result.k = locTemp result.storage = OnStack result.lode = lodeTyp getSysType(p.module.g.graph, unknownLineInfo, tyInt) result.flags = {} proc localVarDecl(p: BProc; n: PNode): Rope = let s = n.sym if s.loc.k == locNone: fillLoc(s.loc, locLocalVar, n, mangleLocalName(p, s), OnStack) if s.kind == skLet: incl(s.loc.flags, lfNoDeepCopy) if s.kind in {skLet, skVar, skField, skForVar} and s.alignment > 0: result.addf("NIM_ALIGN($1) ", [rope(s.alignment)]) result.add getTypeDesc(p.module, s.typ, skVar) if s.constraint.isNil: if sfRegister in s.flags: result.add(" register") #elif skipTypes(s.typ, abstractInst).kind in GcTypeKinds: # decl.add(" GC_GUARD") if sfVolatile in s.flags: result.add(" volatile") if sfNoalias in s.flags: result.add(" NIM_NOALIAS") result.add(" ") result.add(s.loc.r) else: result = runtimeFormat(s.cgDeclFrmt, [result, s.loc.r]) proc assignLocalVar(p: BProc, n: PNode) = #assert(s.loc.k == locNone) # not yet assigned # this need not be fulfilled for inline procs; they are regenerated # for each module that uses them! let nl = if optLineDir in p.config.options: "" else: "\L" let decl = localVarDecl(p, n) & ";" & nl line(p, cpsLocals, decl) include ccgthreadvars proc varInDynamicLib(m: BModule, sym: PSym) proc treatGlobalDifferentlyForHCR(m: BModule, s: PSym): bool = return m.hcrOn and {sfThread, sfGlobal} * s.flags == {sfGlobal} and ({lfNoDecl, lfHeader} * s.loc.flags == {}) # and s.owner.kind == skModule # owner isn't always a module (global pragma on local var) # and s.loc.k == locGlobalVar # loc isn't always initialized when this proc is used proc assignGlobalVar(p: BProc, n: PNode; value: Rope) = let s = n.sym if s.loc.k == locNone: fillLoc(s.loc, locGlobalVar, n, mangleName(p.module, s), OnHeap) if treatGlobalDifferentlyForHCR(p.module, s): incl(s.loc.flags, lfIndirect) if lfDynamicLib in s.loc.flags: var q = findPendingModule(p.module, s) if q != nil and not containsOrIncl(q.declaredThings, s.id): varInDynamicLib(q, s) else: s.loc.r = mangleDynLibProc(s) if value != nil: internalError(p.config, n.info, ".dynlib variables cannot have a value") return useHeader(p.module, s) if lfNoDecl in s.loc.flags: return if not containsOrIncl(p.module.declaredThings, s.id): if sfThread in s.flags: declareThreadVar(p.module, s, sfImportc in s.flags) if value != nil: internalError(p.config, n.info, ".threadvar variables cannot have a value") else: var decl: Rope = nil var td = getTypeDesc(p.module, s.loc.t, skVar) if s.constraint.isNil: if s.kind in {skLet, skVar, skField, skForVar} and s.alignment > 0: decl.addf "NIM_ALIGN($1) ", [rope(s.alignment)] if p.hcrOn: decl.add("static ") elif sfImportc in s.flags: decl.add("extern ") elif lfExportLib in s.loc.flags: decl.add("N_LIB_EXPORT_VAR ") else: decl.add("N_LIB_PRIVATE ") if s.kind == skLet and value != nil: decl.add("NIM_CONST ") decl.add(td) if p.hcrOn: decl.add("*") if sfRegister in s.flags: decl.add(" register") if sfVolatile in s.flags: decl.add(" volatile") if sfNoalias in s.flags: decl.add(" NIM_NOALIAS") if value != nil: decl.addf(" $1 = $2;$n", [s.loc.r, value]) else: decl.addf(" $1;$n", [s.loc.r]) else: if value != nil: decl = runtimeFormat(s.cgDeclFrmt & " = $#;$n", [td, s.loc.r, value]) else: decl = runtimeFormat(s.cgDeclFrmt & ";$n", [td, s.loc.r]) p.module.s[cfsVars].add(decl) if p.withinLoop > 0 and value == nil: # fixes tests/run/tzeroarray: resetLoc(p, s.loc) proc assignParam(p: BProc, s: PSym, retType: PType) = assert(s.loc.r != nil) scopeMangledParam(p, s) proc fillProcLoc(m: BModule; n: PNode) = let sym = n.sym if sym.loc.k == locNone: fillLoc(sym.loc, locProc, n, mangleName(m, sym), OnStack) proc getLabel(p: BProc): TLabel = inc(p.labels) result = "LA" & rope(p.labels) & "_" proc fixLabel(p: BProc, labl: TLabel) = lineF(p, cpsStmts, "$1: ;$n", [labl]) proc genVarPrototype(m: BModule, n: PNode) proc requestConstImpl(p: BProc, sym: PSym) proc genStmts(p: BProc, t: PNode) proc expr(p: BProc, n: PNode, d: var TLoc) proc genProcPrototype(m: BModule, sym: PSym) proc putLocIntoDest(p: BProc, d: var TLoc, s: TLoc) proc intLiteral(i: BiggestInt): Rope proc genLiteral(p: BProc, n: PNode): Rope proc genOtherArg(p: BProc; ri: PNode; i: int; typ: PType): Rope proc raiseExit(p: BProc) proc initLocExpr(p: BProc, e: PNode, result: var TLoc) = initLoc(result, locNone, e, OnUnknown) expr(p, e, result) proc initLocExprSingleUse(p: BProc, e: PNode, result: var TLoc) = initLoc(result, locNone, e, OnUnknown) if e.kind in nkCallKinds and (e[0].kind != nkSym or e[0].sym.magic == mNone): # We cannot check for tfNoSideEffect here because of mutable parameters. discard "bug #8202; enforce evaluation order for nested calls for C++ too" # We may need to consider that 'f(g())' cannot be rewritten to 'tmp = g(); f(tmp)' # if 'tmp' lacks a move/assignment operator. if e[0].kind == nkSym and sfCompileToCpp in e[0].sym.flags: result.flags.incl lfSingleUse else: result.flags.incl lfSingleUse expr(p, e, result) include ccgcalls, "ccgstmts.nim" proc initFrame(p: BProc, procname, filename: Rope): Rope = const frameDefines = """ $1 define nimfr_(proc, file) \ TFrame FR_; \ FR_.procname = proc; FR_.filename = file; FR_.line = 0; FR_.len = 0; #nimFrame(&FR_); $1 define nimfrs_(proc, file, slots, length) \ struct {TFrame* prev;NCSTRING procname;NI line;NCSTRING filename; NI len; VarSlot s[slots];} FR_; \ FR_.procname = proc; FR_.filename = file; FR_.line = 0; FR_.len = length; #nimFrame((TFrame*)&FR_); $1 define nimln_(n, file) \ FR_.line = n; FR_.filename = file; """ if p.module.s[cfsFrameDefines].len == 0: appcg(p.module, p.module.s[cfsFrameDefines], frameDefines, ["#"]) discard cgsym(p.module, "nimFrame") result = ropecg(p.module, "\tnimfr_($1, $2);$n", [procname, filename]) proc initFrameNoDebug(p: BProc; frame, procname, filename: Rope; line: int): Rope = discard cgsym(p.module, "nimFrame") p.blocks[0].sections[cpsLocals].addf("TFrame $1;$n", [frame]) result = ropecg(p.module, "\t$1.procname = $2; $1.filename = $3; " & " $1.line = $4; $1.len = -1; nimFrame(&$1);$n", [frame, procname, filename, line]) proc deinitFrameNoDebug(p: BProc; frame: Rope): Rope = result = ropecg(p.module, "\t#popFrameOfAddr(&$1);$n", [frame]) proc deinitFrame(p: BProc): Rope = result = ropecg(p.module, "\t#popFrame();$n", []) include ccgexprs # ----------------------------- dynamic library handling ----------------- # We don't finalize dynamic libs as the OS does this for us. proc isGetProcAddr(lib: PLib): bool = let n = lib.path result = n.kind in nkCallKinds and n.typ != nil and n.typ.kind in {tyPointer, tyProc} proc loadDynamicLib(m: BModule, lib: PLib) = assert(lib != nil) if not lib.generated: lib.generated = true var tmp = getTempName(m) assert(lib.name == nil) lib.name = tmp # BUGFIX: cgsym has awful side-effects m.s[cfsVars].addf("static void* $1;$n", [tmp]) if lib.path.kind in {nkStrLit..nkTripleStrLit}: var s: TStringSeq = @[] libCandidates(lib.path.strVal, s) rawMessage(m.config, hintDependency, lib.path.strVal) var loadlib: Rope = nil for i in 0..high(s): inc(m.labels) if i > 0: loadlib.add("||") let n = newStrNode(nkStrLit, s[i]) n.info = lib.path.info appcg(m, loadlib, "($1 = #nimLoadLibrary($2))$n", [tmp, genStringLiteral(m, n)]) appcg(m, m.s[cfsDynLibInit], "if (!($1)) #nimLoadLibraryError($2);$n", [loadlib, genStringLiteral(m, lib.path)]) else: var p = newProc(nil, m) p.options.excl optStackTrace p.flags.incl nimErrorFlagDisabled var dest: TLoc initLoc(dest, locTemp, lib.path, OnStack) dest.r = getTempName(m) appcg(m, m.s[cfsDynLibInit],"$1 $2;$n", [getTypeDesc(m, lib.path.typ, skVar), rdLoc(dest)]) expr(p, lib.path, dest) m.s[cfsVars].add(p.s(cpsLocals)) m.s[cfsDynLibInit].add(p.s(cpsInit)) m.s[cfsDynLibInit].add(p.s(cpsStmts)) appcg(m, m.s[cfsDynLibInit], "if (!($1 = #nimLoadLibrary($2))) #nimLoadLibraryError($2);$n", [tmp, rdLoc(dest)]) if lib.name == nil: internalError(m.config, "loadDynamicLib") proc mangleDynLibProc(sym: PSym): Rope = # we have to build this as a single rope in order not to trip the # optimization in genInfixCall, see test tests/cpp/t8241.nim if sfCompilerProc in sym.flags: # NOTE: sym.loc.r is the external name! result = rope(sym.name.s) else: result = rope(strutils.`%`("Dl_$1_", $sym.id)) proc symInDynamicLib(m: BModule, sym: PSym) = var lib = sym.annex let isCall = isGetProcAddr(lib) var extname = sym.loc.r if not isCall: loadDynamicLib(m, lib) var tmp = mangleDynLibProc(sym) sym.loc.r = tmp # from now on we only need the internal name sym.typ.sym = nil # generate a new name inc(m.labels, 2) if isCall: let n = lib.path var a: TLoc initLocExpr(m.initProc, n[0], a) var params = rdLoc(a) & "(" for i in 1.. 0: result = easyResultAsgn(n[0]) if result != nil: incl n.flags, nfPreventCg else: discard type InitResultEnum = enum Unknown, InitSkippable, InitRequired proc allPathsAsgnResult(n: PNode): InitResultEnum = # Exceptions coming from calls don't have not be considered here: # # proc bar(): string = raise newException(...) # # proc foo(): string = # # optimized out: 'reset(result)' # result = bar() # # try: # a = foo() # except: # echo "a was not written to" # template allPathsInBranch(it) = let a = allPathsAsgnResult(it) case a of InitRequired: return InitRequired of InitSkippable: discard of Unknown: # sticky, but can be overwritten by InitRequired: result = Unknown result = Unknown case n.kind of nkStmtList, nkStmtListExpr: for it in n: result = allPathsAsgnResult(it) if result != Unknown: return result of nkAsgn, nkFastAsgn: if n[0].kind == nkSym and n[0].sym.kind == skResult: if not containsResult(n[1]): result = InitSkippable else: result = InitRequired elif containsResult(n): result = InitRequired of nkReturnStmt: if n.len > 0: if n[0].kind == nkEmpty and result != InitSkippable: # This is a bare `return` statement, if `result` was not initialized # anywhere else (or if we're not sure about this) let's require it to be # initialized. This avoids cases like #9286 where this heuristic lead to # wrong code being generated. result = InitRequired else: result = allPathsAsgnResult(n[0]) of nkIfStmt, nkIfExpr: var exhaustive = false result = InitSkippable for it in n: # Every condition must not use 'result': if it.len == 2 and containsResult(it[0]): return InitRequired if it.len == 1: exhaustive = true allPathsInBranch(it.lastSon) # if the 'if' statement is not exhaustive and yet it touched 'result' # in some way, say Unknown. if not exhaustive: result = Unknown of nkCaseStmt: if containsResult(n[0]): return InitRequired result = InitSkippable var exhaustive = skipTypes(n[0].typ, abstractVarRange-{tyTypeDesc}).kind notin {tyFloat..tyFloat128, tyString} for i in 1..= prc.ast.len: internalError(m.config, prc.info, "proc has no result symbol") let resNode = prc.ast[resultPos] let res = resNode.sym # get result symbol if not isInvalidReturnType(m.config, prc.typ[0]): if sfNoInit in prc.flags: incl(res.flags, sfNoInit) if sfNoInit in prc.flags and p.module.compileToCpp and (let val = easyResultAsgn(procBody); val != nil): var decl = localVarDecl(p, resNode) var a: TLoc initLocExprSingleUse(p, val, a) linefmt(p, cpsStmts, "$1 = $2;$n", [decl, rdLoc(a)]) else: # declare the result symbol: assignLocalVar(p, resNode) assert(res.loc.r != nil) initLocalVar(p, res, immediateAsgn=false) returnStmt = ropecg(p.module, "\treturn $1;$n", [rdLoc(res.loc)]) else: fillResult(p.config, resNode) assignParam(p, res, prc.typ[0]) # We simplify 'unsureAsgn(result, nil); unsureAsgn(result, x)' # to 'unsureAsgn(result, x)' # Sketch why this is correct: If 'result' points to a stack location # the 'unsureAsgn' is a nop. If it points to a global variable the # global is either 'nil' or points to valid memory and so the RC operation # succeeds without touching not-initialized memory. if sfNoInit in prc.flags: discard elif allPathsAsgnResult(procBody) == InitSkippable: discard else: resetLoc(p, res.loc) if skipTypes(res.typ, abstractInst).kind == tyArray: #incl(res.loc.flags, lfIndirect) res.loc.storage = OnUnknown for i in 1.. 0: m.s[cfsVars].addf "NIM_ALIGN($1) ", [rope(sym.alignment)] m.s[cfsVars].add(if m.hcrOn: "static " else: "extern ") m.s[cfsVars].add(getTypeDesc(m, sym.loc.t, skVar)) if m.hcrOn: m.s[cfsVars].add("*") if lfDynamicLib in sym.loc.flags: m.s[cfsVars].add("*") if sfRegister in sym.flags: m.s[cfsVars].add(" register") if sfVolatile in sym.flags: m.s[cfsVars].add(" volatile") if sfNoalias in sym.flags: m.s[cfsVars].add(" NIM_NOALIAS") m.s[cfsVars].addf(" $1;$n", [sym.loc.r]) if m.hcrOn: m.initProc.procSec(cpsLocals).addf( "\t$1 = ($2*)hcrGetGlobal($3, \"$1\");$n", [sym.loc.r, getTypeDesc(m, sym.loc.t, skVar), getModuleDllPath(m, sym)]) proc addNimDefines(result: var Rope; conf: ConfigRef) {.inline.} = result.addf("#define NIM_INTBITS $1\L", [ platform.CPU[conf.target.targetCPU].intSize.rope]) if conf.cppCustomNamespace.len > 0: result.add("#define USE_NIM_NAMESPACE ") result.add(conf.cppCustomNamespace) result.add("\L") if conf.isDefined("nimEmulateOverflowChecks"): result.add("#define NIM_EmulateOverflowChecks\L") proc headerTop(): Rope = result = "/* Generated by Nim Compiler v$1 */$N" % [rope(VersionAsString)] proc getCopyright(conf: ConfigRef; cfile: Cfile): Rope = result = headerTop() if optCompileOnly notin conf.globalOptions: result.add ("/* Compiled for: $1, $2, $3 */$N" & "/* Command for C compiler:$n $4 */$N") % [rope(platform.OS[conf.target.targetOS].name), rope(platform.CPU[conf.target.targetCPU].name), rope(extccomp.CC[conf.cCompiler].name), rope(getCompileCFileCmd(conf, cfile))] proc getFileHeader(conf: ConfigRef; cfile: Cfile): Rope = result = getCopyright(conf, cfile) if conf.hcrOn: result.add("#define NIM_HOT_CODE_RELOADING\L") addNimDefines(result, conf) proc getSomeNameForModule(m: PSym): Rope = assert m.kind == skModule assert m.owner.kind == skPackage if {sfSystemModule, sfMainModule} * m.flags == {}: result = m.owner.name.s.mangle.rope result.add "_" result.add m.name.s.mangle proc getSomeInitName(m: BModule, suffix: string): Rope = if not m.hcrOn: result = getSomeNameForModule(m.module) result.add suffix proc getInitName(m: BModule): Rope = if sfMainModule in m.module.flags: # generate constant name for main module, for "easy" debugging. result = rope"NimMainModule" else: result = getSomeInitName(m, "Init000") proc getDatInitName(m: BModule): Rope = getSomeInitName(m, "DatInit000") proc getHcrInitName(m: BModule): Rope = getSomeInitName(m, "HcrInit000") proc hcrGetProcLoadCode(m: BModule, sym, prefix, handle, getProcFunc: string): Rope proc genMainProc(m: BModule) = ## this function is called in cgenWriteModules after all modules are closed, ## it means raising dependency on the symbols is too late as it will not propagate ## into other modules, only simple rope manipulations are allowed var preMainCode: Rope if m.hcrOn: proc loadLib(handle: string, name: string): Rope = let prc = magicsys.getCompilerProc(m.g.graph, name) assert prc != nil let n = newStrNode(nkStrLit, prc.annex.path.strVal) n.info = prc.annex.path.info appcg(m, result, "\tif (!($1 = #nimLoadLibrary($2)))$N" & "\t\t#nimLoadLibraryError($2);$N", [handle, genStringLiteral(m, n)]) preMainCode.add(loadLib("hcr_handle", "hcrGetProc")) preMainCode.add("\tvoid* rtl_handle;\L") preMainCode.add(loadLib("rtl_handle", "nimGC_setStackBottom")) preMainCode.add(hcrGetProcLoadCode(m, "nimGC_setStackBottom", "nimrtl_", "rtl_handle", "nimGetProcAddr")) preMainCode.add("\tinner = PreMain;\L") preMainCode.add("\tinitStackBottomWith_actual((void *)&inner);\L") preMainCode.add("\t(*inner)();\L") else: preMainCode.add("\tPreMain();\L") const # not a big deal if we always compile these 3 global vars... makes the HCR code easier PosixCmdLine = "N_LIB_PRIVATE int cmdCount;$N" & "N_LIB_PRIVATE char** cmdLine;$N" & "N_LIB_PRIVATE char** gEnv;$N" # The use of a volatile function pointer to call Pre/NimMainInner # prevents inlining of the NimMainInner function and dependent # functions, which might otherwise merge their stack frames. PreMainBody = "$N" & "N_LIB_PRIVATE void PreMainInner(void) {$N" & "$2" & "}$N$N" & PosixCmdLine & "N_LIB_PRIVATE void PreMain(void) {$N" & "\tvoid (*volatile inner)(void);$N" & "\tinner = PreMainInner;$N" & "$1" & "\t(*inner)();$N" & "}$N$N" MainProcs = "\tNimMain();$N" MainProcsWithResult = MainProcs & ("\treturn $1nim_program_result;$N") NimMainInner = "N_LIB_PRIVATE N_CDECL(void, NimMainInner)(void) {$N" & "$1" & "}$N$N" NimMainProc = "N_CDECL(void, NimMain)(void) {$N" & "\tvoid (*volatile inner)(void);$N" & "$4" & "\tinner = NimMainInner;$N" & "$2" & "\t(*inner)();$N" & "}$N$N" NimMainBody = NimMainInner & NimMainProc PosixCMain = "int main(int argc, char** args, char** env) {$N" & "\tcmdLine = args;$N" & "\tcmdCount = argc;$N" & "\tgEnv = env;$N" & MainProcsWithResult & "}$N$N" StandaloneCMain = "int main(void) {$N" & MainProcs & "\treturn 0;$N" & "}$N$N" WinNimMain = NimMainBody WinCMain = "N_STDCALL(int, WinMain)(HINSTANCE hCurInstance, $N" & " HINSTANCE hPrevInstance, $N" & " LPSTR lpCmdLine, int nCmdShow) {$N" & MainProcsWithResult & "}$N$N" WinNimDllMain = NimMainInner & "N_LIB_EXPORT " & NimMainProc WinCDllMain = "BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fwdreason, $N" & " LPVOID lpvReserved) {$N" & "\tif(fwdreason == DLL_PROCESS_ATTACH) {$N" & MainProcs & "}$N" & "\treturn 1;$N}$N$N" PosixNimDllMain = WinNimDllMain PosixCDllMain = "N_LIB_PRIVATE void NIM_POSIX_INIT NimMainInit(void) {$N" & MainProcs & "}$N$N" GenodeNimMain = "extern Genode::Env *nim_runtime_env;$N" & "extern \"C\" void nim_component_construct(Genode::Env*);$N$N" & NimMainBody ComponentConstruct = "void Libc::Component::construct(Libc::Env &env) {$N" & "\t// Set Env used during runtime initialization$N" & "\tnim_runtime_env = &env;$N" & "\tLibc::with_libc([&] () {$N\t" & "\t// Initialize runtime and globals$N" & MainProcs & "\t// Call application construct$N" & "\t\tnim_component_construct(&env);$N" & "\t});$N" & "}$N$N" if m.config.target.targetOS == osWindows and m.config.globalOptions * {optGenGuiApp, optGenDynLib} != {}: m.includeHeader("") elif m.config.target.targetOS == osGenode: m.includeHeader("") let initStackBottomCall = if m.config.target.targetOS == osStandalone or m.config.selectedGC == gcNone: "".rope else: ropecg(m, "\t#initStackBottomWith((void *)&inner);$N", []) inc(m.labels) appcg(m, m.s[cfsProcs], PreMainBody, [m.g.mainDatInit, m.g.otherModsInit]) if m.config.target.targetOS == osWindows and m.config.globalOptions * {optGenGuiApp, optGenDynLib} != {}: if optGenGuiApp in m.config.globalOptions: const nimMain = WinNimMain appcg(m, m.s[cfsProcs], nimMain, [m.g.mainModInit, initStackBottomCall, m.labels, preMainCode]) else: const nimMain = WinNimDllMain appcg(m, m.s[cfsProcs], nimMain, [m.g.mainModInit, initStackBottomCall, m.labels, preMainCode]) elif m.config.target.targetOS == osGenode: const nimMain = GenodeNimMain appcg(m, m.s[cfsProcs], nimMain, [m.g.mainModInit, initStackBottomCall, m.labels, preMainCode]) elif optGenDynLib in m.config.globalOptions: const nimMain = PosixNimDllMain appcg(m, m.s[cfsProcs], nimMain, [m.g.mainModInit, initStackBottomCall, m.labels, preMainCode]) elif m.config.target.targetOS == osStandalone: const nimMain = NimMainBody appcg(m, m.s[cfsProcs], nimMain, [m.g.mainModInit, initStackBottomCall, m.labels, preMainCode]) else: const nimMain = NimMainBody appcg(m, m.s[cfsProcs], nimMain, [m.g.mainModInit, initStackBottomCall, m.labels, preMainCode]) if optNoMain notin m.config.globalOptions: if m.config.cppCustomNamespace.len > 0: m.s[cfsProcs].add closeNamespaceNim() & "using namespace " & m.config.cppCustomNamespace & ";\L" if m.config.target.targetOS == osWindows and m.config.globalOptions * {optGenGuiApp, optGenDynLib} != {}: if optGenGuiApp in m.config.globalOptions: const otherMain = WinCMain appcg(m, m.s[cfsProcs], otherMain, [if m.hcrOn: "*" else: ""]) else: const otherMain = WinCDllMain appcg(m, m.s[cfsProcs], otherMain, []) elif m.config.target.targetOS == osGenode: const otherMain = ComponentConstruct appcg(m, m.s[cfsProcs], otherMain, []) elif optGenDynLib in m.config.globalOptions: const otherMain = PosixCDllMain appcg(m, m.s[cfsProcs], otherMain, []) elif m.config.target.targetOS == osStandalone: const otherMain = StandaloneCMain appcg(m, m.s[cfsProcs], otherMain, []) else: const otherMain = PosixCMain appcg(m, m.s[cfsProcs], otherMain, [if m.hcrOn: "*" else: ""]) if m.config.cppCustomNamespace.len > 0: m.s[cfsProcs].add openNamespaceNim(m.config.cppCustomNamespace) proc registerInitProcs*(g: BModuleList; m: PSym; flags: set[ModuleBackendFlag]) = ## Called from the IC backend. if HasDatInitProc in flags: let datInit = getSomeNameForModule(m) & "DatInit000" g.mainModProcs.addf("N_LIB_PRIVATE N_NIMCALL(void, $1)(void);$N", [datInit]) g.mainDatInit.addf("\t$1();$N", [datInit]) if HasModuleInitProc in flags: let init = getSomeNameForModule(m) & "Init000" g.mainModProcs.addf("N_LIB_PRIVATE N_NIMCALL(void, $1)(void);$N", [init]) let initCall = "\t$1();$N" % [init] if sfMainModule in m.flags: g.mainModInit.add(initCall) elif sfSystemModule in m.flags: g.mainDatInit.add(initCall) # systemInit must called right after systemDatInit if any else: g.otherModsInit.add(initCall) proc whichInitProcs*(m: BModule): set[ModuleBackendFlag] = # called from IC. result = {} if m.hcrOn or m.preInitProc.s(cpsInit).len > 0 or m.preInitProc.s(cpsStmts).len > 0: result.incl HasModuleInitProc for i in cfsTypeInit1..cfsDynLibInit: if m.s[i].len != 0: result.incl HasDatInitProc break proc registerModuleToMain(g: BModuleList; m: BModule) = let init = m.getInitName datInit = m.getDatInitName if m.hcrOn: var hcrModuleMeta = "$nN_LIB_PRIVATE const char* hcr_module_list[] = {$n" % [] let systemModulePath = getModuleDllPath(m, g.modules[g.graph.config.m.systemFileIdx.int].module) let mainModulePath = getModuleDllPath(m, m.module) if sfMainModule in m.module.flags: hcrModuleMeta.addf("\t$1,$n", [systemModulePath]) g.graph.importDeps.withValue(FileIndex(m.module.position), deps): for curr in deps[]: hcrModuleMeta.addf("\t$1,$n", [getModuleDllPath(m, g.modules[curr.int].module)]) hcrModuleMeta.addf("\t\"\"};$n", []) hcrModuleMeta.addf("$nN_LIB_EXPORT N_NIMCALL(void**, HcrGetImportedModules)() { return (void**)hcr_module_list; }$n", []) hcrModuleMeta.addf("$nN_LIB_EXPORT N_NIMCALL(char*, HcrGetSigHash)() { return \"$1\"; }$n$n", [($sigHash(m.module)).rope]) if sfMainModule in m.module.flags: g.mainModProcs.add(hcrModuleMeta) g.mainModProcs.addf("static void* hcr_handle;$N", []) g.mainModProcs.addf("N_LIB_EXPORT N_NIMCALL(void, $1)(void);$N", [init]) g.mainModProcs.addf("N_LIB_EXPORT N_NIMCALL(void, $1)(void);$N", [datInit]) g.mainModProcs.addf("N_LIB_EXPORT N_NIMCALL(void, $1)(void*, N_NIMCALL_PTR(void*, getProcAddr)(void*, char*));$N", [m.getHcrInitName]) g.mainModProcs.addf("N_LIB_EXPORT N_NIMCALL(void, HcrCreateTypeInfos)(void);$N", []) g.mainModInit.addf("\t$1();$N", [init]) g.otherModsInit.addf("\thcrInit((void**)hcr_module_list, $1, $2, $3, hcr_handle, nimGetProcAddr);$n", [mainModulePath, systemModulePath, datInit]) g.mainDatInit.addf("\t$1(hcr_handle, nimGetProcAddr);$N", [m.getHcrInitName]) g.mainDatInit.addf("\thcrAddModule($1);\n", [mainModulePath]) g.mainDatInit.addf("\tHcrCreateTypeInfos();$N", []) # nasty nasty hack to get the command line functionality working with HCR # register the 2 variables on behalf of the os module which might not even # be loaded (in which case it will get collected but that is not a problem) # EDIT: indeed, this hack, in combination with another un-necessary one # (`makeCString` was doing line wrap of string litterals) was root cause for # bug #16265. let osModulePath = ($systemModulePath).replace("stdlib_system", "stdlib_os").rope g.mainDatInit.addf("\thcrAddModule($1);\n", [osModulePath]) g.mainDatInit.add("\tint* cmd_count;\n") g.mainDatInit.add("\tchar*** cmd_line;\n") g.mainDatInit.addf("\thcrRegisterGlobal($1, \"cmdCount\", sizeof(cmd_count), NULL, (void**)&cmd_count);$N", [osModulePath]) g.mainDatInit.addf("\thcrRegisterGlobal($1, \"cmdLine\", sizeof(cmd_line), NULL, (void**)&cmd_line);$N", [osModulePath]) g.mainDatInit.add("\t*cmd_count = cmdCount;\n") g.mainDatInit.add("\t*cmd_line = cmdLine;\n") else: m.s[cfsInitProc].add(hcrModuleMeta) return if m.s[cfsDatInitProc].len > 0: g.mainModProcs.addf("N_LIB_PRIVATE N_NIMCALL(void, $1)(void);$N", [datInit]) g.mainDatInit.addf("\t$1();$N", [datInit]) # Initialization of TLS and GC should be done in between # systemDatInit and systemInit calls if any if sfSystemModule in m.module.flags: if emulatedThreadVars(m.config) and m.config.target.targetOS != osStandalone: g.mainDatInit.add(ropecg(m, "\t#initThreadVarsEmulation();$N", [])) if m.config.target.targetOS != osStandalone and m.config.selectedGC notin {gcNone, gcArc, gcOrc}: g.mainDatInit.add(ropecg(m, "\t#initStackBottomWith((void *)&inner);$N", [])) if m.s[cfsInitProc].len > 0: g.mainModProcs.addf("N_LIB_PRIVATE N_NIMCALL(void, $1)(void);$N", [init]) let initCall = "\t$1();$N" % [init] if sfMainModule in m.module.flags: g.mainModInit.add(initCall) elif sfSystemModule in m.module.flags: g.mainDatInit.add(initCall) # systemInit must called right after systemDatInit if any else: g.otherModsInit.add(initCall) proc genDatInitCode(m: BModule) = ## this function is called in cgenWriteModules after all modules are closed, ## it means raising dependency on the symbols is too late as it will not propagate ## into other modules, only simple rope manipulations are allowed var moduleDatInitRequired = m.hcrOn var prc = "$1 N_NIMCALL(void, $2)(void) {$N" % [rope(if m.hcrOn: "N_LIB_EXPORT" else: "N_LIB_PRIVATE"), getDatInitName(m)] # we don't want to break into such init code - could happen if a line # directive from a function written by the user spills after itself genCLineDir(prc, "generated_not_to_break_here", 999999, m.config) for i in cfsTypeInit1..cfsDynLibInit: if m.s[i].len != 0: moduleDatInitRequired = true prc.add(m.s[i]) prc.addf("}$N$N", []) if moduleDatInitRequired: m.s[cfsDatInitProc].add(prc) #rememberFlag(m.g.graph, m.module, HasDatInitProc) # Very similar to the contents of symInDynamicLib - basically only the # things needed for the hot code reloading runtime procs to be loaded proc hcrGetProcLoadCode(m: BModule, sym, prefix, handle, getProcFunc: string): Rope = let prc = magicsys.getCompilerProc(m.g.graph, sym) assert prc != nil fillProcLoc(m, prc.ast[namePos]) var extname = prefix & sym var tmp = mangleDynLibProc(prc) prc.loc.r = tmp prc.typ.sym = nil if not containsOrIncl(m.declaredThings, prc.id): m.s[cfsVars].addf("static $2 $1;$n", [prc.loc.r, getTypeDesc(m, prc.loc.t, skVar)]) result = "\t$1 = ($2) $3($4, $5);$n" % [tmp, getTypeDesc(m, prc.typ, skVar), getProcFunc.rope, handle.rope, makeCString(prefix & sym)] proc genInitCode(m: BModule) = ## this function is called in cgenWriteModules after all modules are closed, ## it means raising dependency on the symbols is too late as it will not propagate ## into other modules, only simple rope manipulations are allowed var moduleInitRequired = m.hcrOn let initname = getInitName(m) var prc = "$1 N_NIMCALL(void, $2)(void) {$N" % [rope(if m.hcrOn: "N_LIB_EXPORT" else: "N_LIB_PRIVATE"), initname] # we don't want to break into such init code - could happen if a line # directive from a function written by the user spills after itself genCLineDir(prc, "generated_not_to_break_here", 999999, m.config) if m.typeNodes > 0: if m.hcrOn: appcg(m, m.s[cfsTypeInit1], "\t#TNimNode* $1;$N", [m.typeNodesName]) appcg(m, m.s[cfsTypeInit1], "\thcrRegisterGlobal($3, \"$1_$2\", sizeof(TNimNode) * $2, NULL, (void**)&$1);$N", [m.typeNodesName, m.typeNodes, getModuleDllPath(m, m.module)]) else: appcg(m, m.s[cfsTypeInit1], "static #TNimNode $1[$2];$n", [m.typeNodesName, m.typeNodes]) if m.nimTypes > 0: appcg(m, m.s[cfsTypeInit1], "static #TNimType $1[$2];$n", [m.nimTypesName, m.nimTypes]) if m.hcrOn: prc.addf("\tint* nim_hcr_dummy_ = 0;$n" & "\tNIM_BOOL nim_hcr_do_init_ = " & "hcrRegisterGlobal($1, \"module_initialized_\", 1, NULL, (void**)&nim_hcr_dummy_);$n", [getModuleDllPath(m, m.module)]) template writeSection(thing: untyped, section: TCProcSection, addHcrGuards = false) = if m.thing.s(section).len > 0: moduleInitRequired = true if addHcrGuards: prc.add("\tif (nim_hcr_do_init_) {\n\n") prc.add(m.thing.s(section)) if addHcrGuards: prc.add("\n\t} // nim_hcr_do_init_\n") if m.preInitProc.s(cpsInit).len > 0 or m.preInitProc.s(cpsStmts).len > 0: # Give this small function its own scope prc.addf("{$N", []) # Keep a bogus frame in case the code needs one prc.add(~"\tTFrame FR_; FR_.len = 0;$N") writeSection(preInitProc, cpsLocals) writeSection(preInitProc, cpsInit, m.hcrOn) writeSection(preInitProc, cpsStmts) prc.addf("}/* preInitProc end */$N", []) when false: m.initProc.blocks[0].sections[cpsLocals].add m.preInitProc.s(cpsLocals) m.initProc.blocks[0].sections[cpsInit].prepend m.preInitProc.s(cpsInit) m.initProc.blocks[0].sections[cpsStmts].prepend m.preInitProc.s(cpsStmts) # add new scope for following code, because old vcc compiler need variable # be defined at the top of the block prc.addf("{$N", []) writeSection(initProc, cpsLocals) if m.initProc.s(cpsInit).len > 0 or m.initProc.s(cpsStmts).len > 0: moduleInitRequired = true if optStackTrace in m.initProc.options and frameDeclared notin m.flags: # BUT: the generated init code might depend on a current frame, so # declare it nevertheless: incl m.flags, frameDeclared if preventStackTrace notin m.flags: var procname = makeCString(m.module.name.s) prc.add(initFrame(m.initProc, procname, quotedFilename(m.config, m.module.info))) else: prc.add(~"\tTFrame FR_; FR_.len = 0;$N") writeSection(initProc, cpsInit, m.hcrOn) writeSection(initProc, cpsStmts) if beforeRetNeeded in m.initProc.flags: prc.add(~"\tBeforeRet_: ;$n") if sfMainModule in m.module.flags and m.config.exc == excGoto: if getCompilerProc(m.g.graph, "nimTestErrorFlag") != nil: m.appcg(prc, "\t#nimTestErrorFlag();$n", []) if optStackTrace in m.initProc.options and preventStackTrace notin m.flags: prc.add(deinitFrame(m.initProc)) prc.addf("}$N", []) prc.addf("}$N$N", []) # we cannot simply add the init proc to ``m.s[cfsProcs]`` anymore because # that would lead to a *nesting* of merge sections which the merger does # not support. So we add it to another special section: ``cfsInitProc`` if m.hcrOn: var procsToLoad = @["hcrRegisterProc", "hcrGetProc", "hcrRegisterGlobal", "hcrGetGlobal"] m.s[cfsInitProc].addf("N_LIB_EXPORT N_NIMCALL(void, $1)(void* handle, N_NIMCALL_PTR(void*, getProcAddr)(void*, char*)) {$N", [getHcrInitName(m)]) if sfMainModule in m.module.flags: # additional procs to load procsToLoad.add("hcrInit") procsToLoad.add("hcrAddModule") # load procs for curr in procsToLoad: m.s[cfsInitProc].add(hcrGetProcLoadCode(m, curr, "", "handle", "getProcAddr")) m.s[cfsInitProc].addf("}$N$N", []) for i, el in pairs(m.extensionLoaders): if el != nil: let ex = "NIM_EXTERNC N_NIMCALL(void, nimLoadProcs$1)(void) {$2}$N$N" % [(i.ord - '0'.ord).rope, el] moduleInitRequired = true prc.add(ex) if moduleInitRequired or sfMainModule in m.module.flags: m.s[cfsInitProc].add(prc) #rememberFlag(m.g.graph, m.module, HasModuleInitProc) genDatInitCode(m) if m.hcrOn: m.s[cfsInitProc].addf("N_LIB_EXPORT N_NIMCALL(void, HcrCreateTypeInfos)(void) {$N", []) m.s[cfsInitProc].add(m.hcrCreateTypeInfosProc) m.s[cfsInitProc].addf("}$N$N", []) registerModuleToMain(m.g, m) proc genModule(m: BModule, cfile: Cfile): Rope = var moduleIsEmpty = true result = getFileHeader(m.config, cfile) generateThreadLocalStorage(m) generateHeaders(m) result.add(m.s[cfsHeaders]) if m.config.cppCustomNamespace.len > 0: result.add openNamespaceNim(m.config.cppCustomNamespace) if m.s[cfsFrameDefines].len > 0: result.add(m.s[cfsFrameDefines]) else: result.add("#define nimfr_(x, y)\n#define nimln_(x, y)\n") for i in cfsForwardTypes..cfsProcs: if m.s[i].len > 0: moduleIsEmpty = false result.add(m.s[i]) if m.s[cfsInitProc].len > 0: moduleIsEmpty = false result.add(m.s[cfsInitProc]) if m.s[cfsDatInitProc].len > 0 or m.hcrOn: moduleIsEmpty = false result.add(m.s[cfsDatInitProc]) if m.config.cppCustomNamespace.len > 0: result.add closeNamespaceNim() if moduleIsEmpty: result = nil proc initProcOptions(m: BModule): TOptions = let opts = m.config.options if sfSystemModule in m.module.flags: opts-{optStackTrace} else: opts proc rawNewModule(g: BModuleList; module: PSym, filename: AbsoluteFile): BModule = new(result) result.g = g result.tmpBase = rope("TM" & $hashOwner(module) & "_") result.headerFiles = @[] result.declaredThings = initIntSet() result.declaredProtos = initIntSet() result.cfilename = filename result.filename = filename result.typeCache = initTable[SigHash, Rope]() result.forwTypeCache = initTable[SigHash, Rope]() result.module = module result.typeInfoMarker = initTable[SigHash, Rope]() result.sigConflicts = initCountTable[SigHash]() result.initProc = newProc(nil, result) result.initProc.options = initProcOptions(result) result.preInitProc = newProc(nil, result) result.preInitProc.flags.incl nimErrorFlagDisabled result.preInitProc.labels = 100_000 # little hack so that unique temporaries are generated initNodeTable(result.dataCache) result.typeStack = @[] result.typeNodesName = getTempName(result) result.nimTypesName = getTempName(result) # no line tracing for the init sections of the system module so that we # don't generate a TFrame which can confuse the stack bottom initialization: if sfSystemModule in module.flags: incl result.flags, preventStackTrace excl(result.preInitProc.options, optStackTrace) let ndiName = if optCDebug in g.config.globalOptions: changeFileExt(completeCfilePath(g.config, filename), "ndi") else: AbsoluteFile"" open(result.ndi, ndiName, g.config) proc rawNewModule(g: BModuleList; module: PSym; conf: ConfigRef): BModule = result = rawNewModule(g, module, AbsoluteFile toFullPath(conf, module.position.FileIndex)) proc newModule*(g: BModuleList; module: PSym; conf: ConfigRef): BModule = # we should create only one cgen module for each module sym result = rawNewModule(g, module, conf) if module.position >= g.modules.len: setLen(g.modules, module.position + 1) #growCache g.modules, module.position g.modules[module.position] = result template injectG() {.dirty.} = if graph.backend == nil: graph.backend = newModuleList(graph) let g = BModuleList(graph.backend) when not defined(nimHasSinkInference): {.pragma: nosinks.} proc myOpen(graph: ModuleGraph; module: PSym; idgen: IdGenerator): PPassContext {.nosinks.} = injectG() result = newModule(g, module, graph.config) result.idgen = idgen if optGenIndex in graph.config.globalOptions and g.generatedHeader == nil: let f = if graph.config.headerFile.len > 0: AbsoluteFile graph.config.headerFile else: graph.config.projectFull g.generatedHeader = rawNewModule(g, module, changeFileExt(completeCfilePath(graph.config, f), hExt)) incl g.generatedHeader.flags, isHeaderFile proc writeHeader(m: BModule) = var result = headerTop() var guard = "__$1__" % [m.filename.splitFile.name.rope] result.addf("#ifndef $1$n#define $1$n", [guard]) addNimDefines(result, m.config) generateHeaders(m) generateThreadLocalStorage(m) for i in cfsHeaders..cfsProcs: result.add(m.s[i]) if m.config.cppCustomNamespace.len > 0 and i == cfsHeaders: result.add openNamespaceNim(m.config.cppCustomNamespace) result.add(m.s[cfsInitProc]) if optGenDynLib in m.config.globalOptions: result.add("N_LIB_IMPORT ") result.addf("N_CDECL(void, NimMain)(void);$n", []) if m.config.cppCustomNamespace.len > 0: result.add closeNamespaceNim() result.addf("#endif /* $1 */$n", [guard]) if not writeRope(result, m.filename): rawMessage(m.config, errCannotOpenFile, m.filename.string) proc getCFile(m: BModule): AbsoluteFile = let ext = if m.compileToCpp: ".nim.cpp" elif m.config.backend == backendObjc or sfCompileToObjc in m.module.flags: ".nim.m" else: ".nim.c" result = changeFileExt(completeCfilePath(m.config, withPackageName(m.config, m.cfilename)), ext) when false: proc myOpenCached(graph: ModuleGraph; module: PSym, rd: PRodReader): PPassContext = injectG() var m = newModule(g, module, graph.config) readMergeInfo(getCFile(m), m) result = m proc addHcrInitGuards(p: BProc, n: PNode, inInitGuard: var bool) = if n.kind == nkStmtList: for child in n: addHcrInitGuards(p, child, inInitGuard) else: let stmtShouldExecute = n.kind in {nkVarSection, nkLetSection} or nfExecuteOnReload in n.flags if inInitGuard: if stmtShouldExecute: endBlock(p) inInitGuard = false else: if not stmtShouldExecute: line(p, cpsStmts, "if (nim_hcr_do_init_)\n") startBlock(p) inInitGuard = true genStmts(p, n) proc genTopLevelStmt*(m: BModule; n: PNode) = ## Also called from `ic/cbackend.nim`. if passes.skipCodegen(m.config, n): return m.initProc.options = initProcOptions(m) #softRnl = if optLineDir in m.config.options: noRnl else: rnl # XXX replicate this logic! var transformedN = transformStmt(m.g.graph, m.idgen, m.module, n) if sfInjectDestructors in m.module.flags: transformedN = injectDestructorCalls(m.g.graph, m.idgen, m.module, transformedN) if m.hcrOn: addHcrInitGuards(m.initProc, transformedN, m.inHcrInitGuard) else: genProcBody(m.initProc, transformedN) proc myProcess(b: PPassContext, n: PNode): PNode = result = n if b != nil: var m = BModule(b) genTopLevelStmt(m, n) proc shouldRecompile(m: BModule; code: Rope, cfile: Cfile): bool = if optForceFullMake notin m.config.globalOptions: if not moduleHasChanged(m.g.graph, m.module): result = false elif not equalsFile(code, cfile.cname): when false: #m.config.symbolFiles == readOnlySf: #isDefined(m.config, "nimdiff"): if fileExists(cfile.cname): copyFile(cfile.cname.string, cfile.cname.string & ".backup") echo "diff ", cfile.cname.string, ".backup ", cfile.cname.string else: echo "new file ", cfile.cname.string if not writeRope(code, cfile.cname): rawMessage(m.config, errCannotOpenFile, cfile.cname.string) result = true elif fileExists(cfile.obj) and os.fileNewer(cfile.obj.string, cfile.cname.string): result = false else: result = true else: if not writeRope(code, cfile.cname): rawMessage(m.config, errCannotOpenFile, cfile.cname.string) result = true # We need 2 different logics here: pending modules (including # 'nim__dat') may require file merging for the combination of dead code # elimination and incremental compilation! Non pending modules need no # such logic and in fact the logic hurts for the main module at least; # it would generate multiple 'main' procs, for instance. proc writeModule(m: BModule, pending: bool) = template onExit() = close(m.ndi, m.config) let cfile = getCFile(m) if moduleHasChanged(m.g.graph, m.module): genInitCode(m) finishTypeDescriptions(m) if sfMainModule in m.module.flags: # generate main file: genMainProc(m) m.s[cfsProcHeaders].add(m.g.mainModProcs) generateThreadVarsSize(m) var cf = Cfile(nimname: m.module.name.s, cname: cfile, obj: completeCfilePath(m.config, toObjFile(m.config, cfile)), flags: {}) var code = genModule(m, cf) if code != nil or m.config.symbolFiles != disabledSf: when hasTinyCBackend: if m.config.cmd == cmdTcc: tccgen.compileCCode($code, m.config) onExit() return if not shouldRecompile(m, code, cf): cf.flags = {CfileFlag.Cached} addFileToCompile(m.config, cf) onExit() proc updateCachedModule(m: BModule) = let cfile = getCFile(m) var cf = Cfile(nimname: m.module.name.s, cname: cfile, obj: completeCfilePath(m.config, toObjFile(m.config, cfile)), flags: {}) if sfMainModule notin m.module.flags: genMainProc(m) cf.flags = {CfileFlag.Cached} addFileToCompile(m.config, cf) proc finalCodegenActions*(graph: ModuleGraph; m: BModule; n: PNode) = ## Also called from IC. if sfMainModule in m.module.flags: # phase ordering problem here: We need to announce this # dependency to 'nimTestErrorFlag' before system.c has been written to disk. if m.config.exc == excGoto and getCompilerProc(graph, "nimTestErrorFlag") != nil: discard cgsym(m, "nimTestErrorFlag") if {optGenStaticLib, optGenDynLib, optNoMain} * m.config.globalOptions == {}: for i in countdown(high(graph.globalDestructors), 0): n.add graph.globalDestructors[i] if passes.skipCodegen(m.config, n): return if moduleHasChanged(graph, m.module): # if the module is cached, we don't regenerate the main proc # nor the dispatchers? But if the dispatchers changed? # XXX emit the dispatchers into its own .c file? if n != nil: m.initProc.options = initProcOptions(m) genProcBody(m.initProc, n) if m.hcrOn: # make sure this is pulled in (meaning hcrGetGlobal() is called for it during init) discard cgsym(m, "programResult") if m.inHcrInitGuard: endBlock(m.initProc) if sfMainModule in m.module.flags: if m.hcrOn: # pull ("define" since they are inline when HCR is on) these functions in the main file # so it can load the HCR runtime and later pass the library handle to the HCR runtime which # will in turn pass it to the other modules it initializes so they can initialize the # register/get procs so they don't have to have the definitions of these functions as well discard cgsym(m, "nimLoadLibrary") discard cgsym(m, "nimLoadLibraryError") discard cgsym(m, "nimGetProcAddr") discard cgsym(m, "procAddrError") discard cgsym(m, "rawWrite") # raise dependencies on behalf of genMainProc if m.config.target.targetOS != osStandalone and m.config.selectedGC != gcNone: discard cgsym(m, "initStackBottomWith") if emulatedThreadVars(m.config) and m.config.target.targetOS != osStandalone: discard cgsym(m, "initThreadVarsEmulation") if m.g.forwardedProcs.len == 0: incl m.flags, objHasKidsValid let disp = generateMethodDispatchers(graph) for x in disp: genProcAux(m, x.sym) let mm = m m.g.modulesClosed.add mm proc myClose(graph: ModuleGraph; b: PPassContext, n: PNode): PNode = result = n if b == nil: return finalCodegenActions(graph, BModule(b), n) proc genForwardedProcs(g: BModuleList) = # Forward declared proc:s lack bodies when first encountered, so they're given # a second pass here # Note: ``genProcNoForward`` may add to ``forwardedProcs`` while g.forwardedProcs.len > 0: let prc = g.forwardedProcs.pop() m = g.modules[prc.itemId.module] if sfForward in prc.flags: internalError(m.config, prc.info, "still forwarded: " & prc.name.s) genProcNoForward(m, prc) proc cgenWriteModules*(backend: RootRef, config: ConfigRef) = let g = BModuleList(backend) g.config = config # we need to process the transitive closure because recursive module # deps are allowed (and the system module is processed in the wrong # order anyway) genForwardedProcs(g) for m in cgenModules(g): m.writeModule(pending=true) writeMapping(config, g.mapping) if g.generatedHeader != nil: writeHeader(g.generatedHeader) const cgenPass* = makePass(myOpen, myProcess, myClose)