From 78c5846225124e070c220c2ecaff354ae3593f4d Mon Sep 17 00:00:00 2001 From: ringabout <43030857+ringabout@users.noreply.github.com> Date: Wed, 19 Jun 2024 22:10:00 +0800 Subject: [PATCH] split `PackedModule` into reader and writer --- compiler/ic/ic.nim | 138 ++++++++++++++++++++++++-------------- compiler/ic/integrity.nim | 4 +- compiler/modulegraphs.nim | 16 ++--- compiler/semdata.nim | 2 +- 4 files changed, 98 insertions(+), 62 deletions(-) diff --git a/compiler/ic/ic.nim b/compiler/ic/ic.nim index 22b886ff4db1..c5966d261f3a 100644 --- a/compiler/ic/ic.nim +++ b/compiler/ic/ic.nim @@ -33,7 +33,42 @@ type HasDatInitProc HasModuleInitProc - PackedModule* = object ## the parts of a PackedEncoder that are part of the .rod file + PackedModuleReader* = object ## the parts of a PackedEncoder that are part of the .rod file + definedSymbols: string + moduleFlags: TSymFlags + includes*: seq[(LitId, string)] # first entry is the module filename itself + imports: seq[LitId] # the modules this module depends on + toReplay*: PackedTree # pragmas and VM specific state to replay. + topLevel*: PackedTree # top level statements + bodies*: PackedTree # other trees. Referenced from typ.n and sym.ast by their position. + #producedGenerics*: Table[GenericKey, SymId] + exports*: seq[(LitId, int32)] + hidden: seq[(LitId, int32)] + reexports: seq[(LitId, PackedItemId)] + compilerProcs*: seq[(LitId, int32)] + converters*, methods*, trmacros*, pureEnums*: seq[int32] + + typeInstCache*: seq[(PackedItemId, PackedItemId)] + procInstCache*: seq[PackedInstantiation] + attachedOps*: seq[(PackedItemId, TTypeAttachedOp, PackedItemId)] + methodsPerGenericType*: seq[(PackedItemId, int, PackedItemId)] + enumToStringProcs*: seq[(PackedItemId, PackedItemId)] + methodsPerType*: seq[(PackedItemId, PackedItemId)] + dispatchers*: seq[PackedItemId] + + emittedTypeInfo*: seq[string] + backendFlags*: set[ModuleBackendFlag] + + syms*: OrderedTable[int32, PackedSym] + types*: OrderedTable[int32, PackedType] + strings*: BiTable[string] # we could share these between modules. + numbers*: BiTable[BiggestInt] # we also store floats in here so + # that we can assure that every bit is kept + man*: LineInfoManager + + cfg: PackedConfig + + PackedModuleWriter* = object ## the parts of a PackedEncoder that are part of the .rod file definedSymbols: string moduleFlags: TSymFlags includes*: seq[(LitId, string)] # first entry is the module filename itself @@ -69,7 +104,7 @@ type cfg: PackedConfig PackedEncoder* = object - #m*: PackedModule + #m*: PackedModuleWriter thisModule*: int32 lastFile*: FileIndex # remember the last lookup entry. lastLit*: LitId @@ -80,7 +115,7 @@ type symMarker*: IntSet #Table[ItemId, SymId] # ItemId.item -> SymId config*: ConfigRef -proc toString*(tree: PackedTree; pos: NodePos; m: PackedModule; nesting: int; +proc toString*(tree: PackedTree; pos: NodePos; m: PackedModuleWriter|PackedModuleReader; nesting: int; result: var string) = if result.len > 0 and result[^1] notin {' ', '\n'}: result.add ' ' @@ -116,11 +151,11 @@ proc toString*(tree: PackedTree; pos: NodePos; m: PackedModule; nesting: int; result.add ")" #for i in 1..nesting*2: result.add ' ' -proc toString*(tree: PackedTree; n: NodePos; m: PackedModule): string = +proc toString*(tree: PackedTree; n: NodePos; m: PackedModuleWriter|PackedModuleReader): string = result = "" toString(tree, n, m, 0, result) -proc debug*(tree: PackedTree; m: PackedModule) = +proc debug*(tree: PackedTree; m: PackedModuleWriter|PackedModuleReader) = stdout.write toString(tree, NodePos 0, m) proc isActive*(e: PackedEncoder): bool = e.config != nil @@ -140,7 +175,7 @@ proc definedSymbolsAsString(config: ConfigRef): string = result.add ' ' result.add d -proc rememberConfig(c: var PackedEncoder; m: var PackedModule; config: ConfigRef; pc: PackedConfig) = +proc rememberConfig(c: var PackedEncoder; m: var PackedModuleWriter; config: ConfigRef; pc: PackedConfig) = m.definedSymbols = definedSymbolsAsString(config) #template rem(x) = # c.m.cfg.x = config.x @@ -153,7 +188,7 @@ const when debugConfigDiff: import hashes, tables, intsets, sha1, strutils, sets -proc configIdentical(m: PackedModule; config: ConfigRef): bool = +proc configIdentical(m: PackedModuleReader; config: ConfigRef): bool = result = m.definedSymbols == definedSymbolsAsString(config) when debugConfigDiff: if not result: @@ -183,7 +218,7 @@ proc hashFileCached(conf: ConfigRef; fileIdx: FileIndex): string = result = $secureHashFile(fullpath) msgs.setHash(conf, fileIdx, result) -proc toLitId(x: FileIndex; c: var PackedEncoder; m: var PackedModule): LitId = +proc toLitId(x: FileIndex; c: var PackedEncoder; m: var PackedModuleWriter): LitId = ## store a file index as a literal if x == c.lastFile: result = c.lastLit @@ -197,16 +232,16 @@ proc toLitId(x: FileIndex; c: var PackedEncoder; m: var PackedModule): LitId = c.lastLit = result assert result != LitId(0) -proc toFileIndex*(x: LitId; m: PackedModule; config: ConfigRef): FileIndex = +proc toFileIndex*(x: LitId; m: PackedModuleReader; config: ConfigRef): FileIndex = result = msgs.fileInfoIdx(config, AbsoluteFile m.strings[x]) -proc includesIdentical(m: var PackedModule; config: ConfigRef): bool = +proc includesIdentical(m: var PackedModuleReader; config: ConfigRef): bool = for it in mitems(m.includes): if hashFileCached(config, toFileIndex(it[0], m, config)) != it[1]: return false result = true -proc initEncoder*(c: var PackedEncoder; m: var PackedModule; moduleSym: PSym; config: ConfigRef; pc: PackedConfig) = +proc initEncoder*(c: var PackedEncoder; m: var PackedModuleWriter; moduleSym: PSym; config: ConfigRef; pc: PackedConfig) = ## setup a context for serializing to packed ast c.thisModule = moduleSym.itemId.module c.config = config @@ -228,54 +263,54 @@ proc initEncoder*(c: var PackedEncoder; m: var PackedModule; moduleSym: PSym; co rememberConfig(c, m, config, pc) -proc addIncludeFileDep*(c: var PackedEncoder; m: var PackedModule; f: FileIndex) = +proc addIncludeFileDep*(c: var PackedEncoder; m: var PackedModuleWriter; f: FileIndex) = m.includes.add((toLitId(f, c, m), hashFileCached(c.config, f))) -proc addImportFileDep*(c: var PackedEncoder; m: var PackedModule; f: FileIndex) = +proc addImportFileDep*(c: var PackedEncoder; m: var PackedModuleWriter; f: FileIndex) = m.imports.add toLitId(f, c, m) -proc addHidden*(c: var PackedEncoder; m: var PackedModule; s: PSym) = +proc addHidden*(c: var PackedEncoder; m: var PackedModuleWriter; s: PSym) = assert s.kind != skUnknown let nameId = getOrIncl(m.strings, s.name.s) m.hidden.add((nameId, s.itemId.item)) assert s.itemId.module == c.thisModule -proc addExported*(c: var PackedEncoder; m: var PackedModule; s: PSym) = +proc addExported*(c: var PackedEncoder; m: var PackedModuleWriter; s: PSym) = assert s.kind != skUnknown assert s.itemId.module == c.thisModule let nameId = getOrIncl(m.strings, s.name.s) m.exports.add((nameId, s.itemId.item)) -proc addConverter*(c: var PackedEncoder; m: var PackedModule; s: PSym) = +proc addConverter*(c: var PackedEncoder; m: var PackedModuleWriter; s: PSym) = assert c.thisModule == s.itemId.module m.converters.add(s.itemId.item) -proc addTrmacro*(c: var PackedEncoder; m: var PackedModule; s: PSym) = +proc addTrmacro*(c: var PackedEncoder; m: var PackedModuleWriter; s: PSym) = m.trmacros.add(s.itemId.item) -proc addPureEnum*(c: var PackedEncoder; m: var PackedModule; s: PSym) = +proc addPureEnum*(c: var PackedEncoder; m: var PackedModuleWriter; s: PSym) = assert s.kind == skType m.pureEnums.add(s.itemId.item) -proc addMethod*(c: var PackedEncoder; m: var PackedModule; s: PSym) = +proc addMethod*(c: var PackedEncoder; m: var PackedModuleWriter; s: PSym) = m.methods.add s.itemId.item -proc addReexport*(c: var PackedEncoder; m: var PackedModule; s: PSym) = +proc addReexport*(c: var PackedEncoder; m: var PackedModuleWriter; s: PSym) = assert s.kind != skUnknown if s.kind == skModule: return let nameId = getOrIncl(m.strings, s.name.s) m.reexports.add((nameId, PackedItemId(module: toLitId(s.itemId.module.FileIndex, c, m), item: s.itemId.item))) -proc addCompilerProc*(c: var PackedEncoder; m: var PackedModule; s: PSym) = +proc addCompilerProc*(c: var PackedEncoder; m: var PackedModuleWriter; s: PSym) = let nameId = getOrIncl(m.strings, s.name.s) m.compilerProcs.add((nameId, s.itemId.item)) -proc toPackedNode*(n: PNode; ir: var PackedTree; c: var PackedEncoder; m: var PackedModule) -proc storeSym*(s: PSym; c: var PackedEncoder; m: var PackedModule): PackedItemId -proc storeType(t: PType; c: var PackedEncoder; m: var PackedModule): PackedItemId +proc toPackedNode*(n: PNode; ir: var PackedTree; c: var PackedEncoder; m: var PackedModuleWriter) +proc storeSym*(s: PSym; c: var PackedEncoder; m: var PackedModuleWriter): PackedItemId +proc storeType(t: PType; c: var PackedEncoder; m: var PackedModuleWriter): PackedItemId -proc flush(c: var PackedEncoder; m: var PackedModule) = +proc flush(c: var PackedEncoder; m: var PackedModuleWriter) = ## serialize any pending types or symbols from the context while true: if c.pendingTypes.len > 0: @@ -285,19 +320,19 @@ proc flush(c: var PackedEncoder; m: var PackedModule) = else: break -proc toLitId(x: string; m: var PackedModule): LitId = +proc toLitId(x: string; m: var PackedModuleWriter): LitId = ## store a string as a literal result = getOrIncl(m.strings, x) -proc toLitId(x: BiggestInt; m: var PackedModule): LitId = +proc toLitId(x: BiggestInt; m: var PackedModuleWriter): LitId = ## store an integer as a literal result = getOrIncl(m.numbers, x) -proc toPackedInfo(x: TLineInfo; c: var PackedEncoder; m: var PackedModule): PackedLineInfo = +proc toPackedInfo(x: TLineInfo; c: var PackedEncoder; m: var PackedModuleWriter): PackedLineInfo = pack(m.man, toLitId(x.fileIndex, c, m), x.line.int32, x.col.int32) #PackedLineInfo(line: x.line, col: x.col, file: toLitId(x.fileIndex, c, m)) -proc safeItemId(s: PSym; c: var PackedEncoder; m: var PackedModule): PackedItemId {.inline.} = +proc safeItemId(s: PSym; c: var PackedEncoder; m: var PackedModuleWriter): PackedItemId {.inline.} = ## given a symbol, produce an ItemId with the correct properties ## for local or remote symbols, packing the symbol as necessary if s == nil or s.kind == skPackage: @@ -331,7 +366,7 @@ template storeNode(dest, src, field) = nodeId = emptyNodeId dest.field = nodeId -proc storeTypeLater(t: PType; c: var PackedEncoder; m: var PackedModule): PackedItemId = +proc storeTypeLater(t: PType; c: var PackedEncoder; m: var PackedModuleWriter): PackedItemId = # We store multiple different trees in m.bodies. For this to work out, we # cannot immediately store types/syms. We enqueue them instead to ensure # we only write one tree into m.bodies after the other. @@ -344,7 +379,7 @@ proc storeTypeLater(t: PType; c: var PackedEncoder; m: var PackedModule): Packed # the type belongs to this module, so serialize it here, eventually. addMissing(c, t) -proc storeSymLater(s: PSym; c: var PackedEncoder; m: var PackedModule): PackedItemId = +proc storeSymLater(s: PSym; c: var PackedEncoder; m: var PackedModuleWriter): PackedItemId = if s.isNil: return nilItemId assert s.itemId.module >= 0 assert s.itemId.item >= 0 @@ -353,7 +388,7 @@ proc storeSymLater(s: PSym; c: var PackedEncoder; m: var PackedModule): PackedIt # the sym belongs to this module, so serialize it here, eventually. addMissing(c, s) -proc storeType(t: PType; c: var PackedEncoder; m: var PackedModule): PackedItemId = +proc storeType(t: PType; c: var PackedEncoder; m: var PackedModuleWriter): PackedItemId = ## serialize a ptype if t.isNil: return nilItemId @@ -380,7 +415,7 @@ proc storeType(t: PType; c: var PackedEncoder; m: var PackedModule): PackedItemI # fill the reserved slot, nothing else: m.types[t.uniqueId.item] = p -proc toPackedLib(l: PLib; c: var PackedEncoder; m: var PackedModule): PackedLib = +proc toPackedLib(l: PLib; c: var PackedEncoder; m: var PackedModuleWriter): PackedLib = ## the plib hangs off the psym via the .annex field if l.isNil: return result = PackedLib(kind: l.kind, generated: l.generated, @@ -388,7 +423,7 @@ proc toPackedLib(l: PLib; c: var PackedEncoder; m: var PackedModule): PackedLib ) storeNode(result, l, path) -proc storeSym*(s: PSym; c: var PackedEncoder; m: var PackedModule): PackedItemId = +proc storeSym*(s: PSym; c: var PackedEncoder; m: var PackedModuleWriter): PackedItemId = ## serialize a psym if s.isNil: return nilItemId @@ -428,7 +463,7 @@ proc storeSym*(s: PSym; c: var PackedEncoder; m: var PackedModule): PackedItemId # fill the reserved slot, nothing else: m.syms[s.itemId.item] = p -proc addModuleRef(n: PNode; ir: var PackedTree; c: var PackedEncoder; m: var PackedModule) = +proc addModuleRef(n: PNode; ir: var PackedTree; c: var PackedEncoder; m: var PackedModuleWriter) = ## add a remote symbol reference to the tree let info = n.info.toPackedInfo(c, m) if n.typ != n.sym.typ: @@ -443,7 +478,7 @@ proc addModuleRef(n: PNode; ir: var PackedTree; c: var PackedEncoder; m: var Pac ir.addNode(kind = nkNone, info = info, operand = n.sym.itemId.item) -proc toPackedNode*(n: PNode; ir: var PackedTree; c: var PackedEncoder; m: var PackedModule) = +proc toPackedNode*(n: PNode; ir: var PackedTree; c: var PackedEncoder; m: var PackedModuleWriter) = ## serialize a node into the tree if n == nil: ir.addNode(kind = nkNilRodNode, operand = 1, info = NoLineInfo) @@ -491,13 +526,13 @@ proc toPackedNode*(n: PNode; ir: var PackedTree; c: var PackedEncoder; m: var Pa toPackedNode(n[i], ir, c, m) ir.patch patchPos -proc storeTypeInst*(c: var PackedEncoder; m: var PackedModule; s: PSym; inst: PType) = +proc storeTypeInst*(c: var PackedEncoder; m: var PackedModuleWriter; s: PSym; inst: PType) = m.typeInstCache.add (storeSymLater(s, c, m), storeTypeLater(inst, c, m)) -proc addPragmaComputation*(c: var PackedEncoder; m: var PackedModule; n: PNode) = +proc addPragmaComputation*(c: var PackedEncoder; m: var PackedModuleWriter; n: PNode) = toPackedNode(n, m.toReplay, c, m) -proc toPackedProcDef(n: PNode; ir: var PackedTree; c: var PackedEncoder; m: var PackedModule) = +proc toPackedProcDef(n: PNode; ir: var PackedTree; c: var PackedEncoder; m: var PackedModuleWriter) = let info = toPackedInfo(n.info, c, m) let patchPos = ir.prepare(n.kind, n.flags, storeTypeLater(n.typ, c, m), info) @@ -512,7 +547,7 @@ proc toPackedProcDef(n: PNode; ir: var PackedTree; c: var PackedEncoder; m: var typeId = nilItemId, info = info) ir.patch patchPos -proc toPackedNodeIgnoreProcDefs(n: PNode, encoder: var PackedEncoder; m: var PackedModule) = +proc toPackedNodeIgnoreProcDefs(n: PNode, encoder: var PackedEncoder; m: var PackedModuleWriter) = case n.kind of routineDefs: toPackedProcDef(n, m.topLevel, encoder, m) @@ -534,11 +569,11 @@ proc toPackedNodeIgnoreProcDefs(n: PNode, encoder: var PackedEncoder; m: var Pac else: toPackedNode(n, m.topLevel, encoder, m) -proc toPackedNodeTopLevel*(n: PNode, encoder: var PackedEncoder; m: var PackedModule) = +proc toPackedNodeTopLevel*(n: PNode, encoder: var PackedEncoder; m: var PackedModuleWriter) = toPackedNodeIgnoreProcDefs(n, encoder, m) flush encoder, m -proc toPackedGeneratedProcDef*(s: PSym, encoder: var PackedEncoder; m: var PackedModule) = +proc toPackedGeneratedProcDef*(s: PSym, encoder: var PackedEncoder; m: var PackedModuleWriter) = ## Generic procs and generated `=hook`'s need explicit top-level entries so ## that the code generator can work without having to special case these. These ## entries will also be useful for other tools and are the cleanest design @@ -548,7 +583,7 @@ proc toPackedGeneratedProcDef*(s: PSym, encoder: var PackedEncoder; m: var Packe #flush encoder, m proc storeAttachedProcDef*(t: PType; op: TTypeAttachedOp; s: PSym, - encoder: var PackedEncoder; m: var PackedModule) = + encoder: var PackedEncoder; m: var PackedModuleWriter) = assert s.kind in routineKinds assert isActive(encoder) let tid = storeTypeLater(t, encoder, m) @@ -556,7 +591,7 @@ proc storeAttachedProcDef*(t: PType; op: TTypeAttachedOp; s: PSym, m.attachedOps.add (tid, op, sid) toPackedGeneratedProcDef(s, encoder, m) -proc storeInstantiation*(c: var PackedEncoder; m: var PackedModule; s: PSym; i: PInstantiation) = +proc storeInstantiation*(c: var PackedEncoder; m: var PackedModuleWriter; s: PSym; i: PInstantiation) = var t = newSeq[PackedItemId](i.concreteTypes.len) for j in 0..high(i.concreteTypes): t[j] = storeTypeLater(i.concreteTypes[j], c, m) @@ -565,7 +600,7 @@ proc storeInstantiation*(c: var PackedEncoder; m: var PackedModule; s: PSym; i: concreteTypes: t) toPackedGeneratedProcDef(i.sym, c, m) -proc storeExpansion*(c: var PackedEncoder; m: var PackedModule; info: TLineInfo; s: PSym) = +proc storeExpansion*(c: var PackedEncoder; m: var PackedModuleWriter; info: TLineInfo; s: PSym) = toPackedNode(newSymNode(s, info), m.bodies, c, m) proc loadError(err: RodFileError; filename: AbsoluteFile; config: ConfigRef;) = @@ -596,7 +631,7 @@ when BenchIC: else: template bench(x, body) = body -proc loadRodFile*(filename: AbsoluteFile; m: var PackedModule; config: ConfigRef; +proc loadRodFile*(filename: AbsoluteFile; m: var PackedModuleReader; config: ConfigRef; ignoreConfig = false): RodFileError = var f = rodfiles.open(filename.string) f.loadHeader() @@ -676,7 +711,7 @@ proc storeError(err: RodFileError; filename: AbsoluteFile) = echo "Error: ", $err, "; couldn't write to ", filename.string removeFile(filename.string) -proc saveRodFile*(filename: AbsoluteFile; encoder: var PackedEncoder; m: var PackedModule) = +proc saveRodFile*(filename: AbsoluteFile; encoder: var PackedEncoder; m: var PackedModuleWriter) = flush encoder, m #rememberConfig(encoder, encoder.config) @@ -748,7 +783,7 @@ proc saveRodFile*(filename: AbsoluteFile; encoder: var PackedEncoder; m: var Pac when false: # basic loader testing: - var m2: PackedModule + var m2: PackedModuleReader discard loadRodFile(filename, m2, encoder.config) echo "loaded ", filename.string @@ -774,7 +809,8 @@ type LoadedModule* = object status*: ModuleStatus symsInit, typesInit, loadedButAliveSetChanged*: bool - fromDisk*: PackedModule + fromDisk*: PackedModuleReader + toDisk*: PackedModuleWriter syms: OrderedTable[int32, PSym] # indexed by itemId types: OrderedTable[int32, PType] module*: PSym # the one true module symbol. @@ -1193,7 +1229,7 @@ proc translateId*(id: PackedItemId; g: PackedModuleGraph; thisModule: int; confi ItemId(module: toFileIndex(id.module, g[thisModule].fromDisk, config).int32, item: id.item) proc simulateLoadedModule*(g: var PackedModuleGraph; conf: ConfigRef; cache: IdentCache; - moduleSym: PSym; m: PackedModule) = + moduleSym: PSym; m: PackedModuleWriter) = # For now only used for heavy debugging. In the future we could use this to reduce the # compiler's memory consumption. let idx = moduleSym.position @@ -1291,7 +1327,7 @@ proc searchForCompilerproc*(m: LoadedModule; name: string): int32 = # ------------------------- .rod file viewer --------------------------------- proc rodViewer*(rodfile: AbsoluteFile; config: ConfigRef, cache: IdentCache) = - var m: PackedModule = PackedModule() + var m: PackedModuleReader = PackedModuleReader() let err = loadRodFile(rodfile, m, config, ignoreConfig=true) if err != ok: config.quitOrRaise "Error: could not load: " & $rodfile.string & " reason: " & $err diff --git a/compiler/ic/integrity.nim b/compiler/ic/integrity.nim index 3e8ea25034db..5cf9b22e551e 100644 --- a/compiler/ic/integrity.nim +++ b/compiler/ic/integrity.nim @@ -100,11 +100,11 @@ proc checkNode(c: var CheckedContext; tree: PackedTree; n: NodePos) = proc checkTree(c: var CheckedContext; t: PackedTree) = for p in allNodes(t): checkNode(c, t, p) -proc checkLocalSymIds(c: var CheckedContext; m: PackedModule; symIds: seq[int32]) = +proc checkLocalSymIds(c: var CheckedContext; m: PackedModuleReader; symIds: seq[int32]) = for symId in symIds: assert symId >= 0 and symId < m.syms.len, $symId & " " & $m.syms.len -proc checkModule(c: var CheckedContext; m: PackedModule) = +proc checkModule(c: var CheckedContext; m: PackedModuleReader) = # We check that: # - Every symbol references existing types and symbols. # - Every tree node references existing types and symbols. diff --git a/compiler/modulegraphs.nim b/compiler/modulegraphs.nim index 75f3a3c70bde..093950c79a89 100644 --- a/compiler/modulegraphs.nim +++ b/compiler/modulegraphs.nim @@ -220,7 +220,7 @@ proc isCachedModule(g: ModuleGraph; module: int): bool {.inline.} = proc isCachedModule*(g: ModuleGraph; m: PSym): bool {.inline.} = isCachedModule(g, m.position) -proc simulateCachedModule(g: ModuleGraph; moduleSym: PSym; m: PackedModule) = +proc simulateCachedModule(g: ModuleGraph; moduleSym: PSym; m: PackedModuleWriter) = when false: echo "simulating ", moduleSym.name.s, " ", moduleSym.position simulateLoadedModule(g.packed, g.config, g.cache, moduleSym, m) @@ -230,7 +230,7 @@ proc initEncoder*(g: ModuleGraph; module: PSym) = if id >= g.encoders.len: setLen g.encoders, id+1 ic.initEncoder(g.encoders[id], - g.packed[id].fromDisk, module, g.config, g.startupPackedConfig) + g.packed[id].toDisk, module, g.config, g.startupPackedConfig) type ModuleIter* = object @@ -351,8 +351,8 @@ proc completePartialOp*(g: ModuleGraph; module: int; t: PType; op: TTypeAttached if g.config.symbolFiles != disabledSf: assert module < g.encoders.len assert isActive(g.encoders[module]) - toPackedGeneratedProcDef(value, g.encoders[module], g.packed[module].fromDisk) - #storeAttachedProcDef(t, op, value, g.encoders[module], g.packed[module].fromDisk) + toPackedGeneratedProcDef(value, g.encoders[module], g.packed[module].toDisk) + #storeAttachedProcDef(t, op, value, g.encoders[module], g.packed[module].toDisk) iterator getDispatchers*(g: ModuleGraph): PSym = for i in g.dispatchers.mitems: @@ -555,14 +555,14 @@ proc rememberEmittedTypeInfo*(g: ModuleGraph; m: FileIndex; ti: string) = if g.config.symbolFiles != disabledSf: #assert g.encoders[m.int32].isActive assert g.packed[m.int32].status != stored - g.packed[m.int32].fromDisk.emittedTypeInfo.add ti + g.packed[m.int32].toDisk.emittedTypeInfo.add ti #echo "added typeinfo ", m.int32, " ", ti, " suspicious ", not g.encoders[m.int32].isActive proc rememberFlag*(g: ModuleGraph; m: PSym; flag: ModuleBackendFlag) = if g.config.symbolFiles != disabledSf: #assert g.encoders[m.int32].isActive assert g.packed[m.position].status != stored - g.packed[m.position].fromDisk.backendFlags.incl flag + g.packed[m.position].toDisk.backendFlags.incl flag proc closeRodFile*(g: ModuleGraph; m: PSym) = if g.config.symbolFiles in {readOnlySf, v2Sf}: @@ -571,14 +571,14 @@ proc closeRodFile*(g: ModuleGraph; m: PSym) = # not depend on the hard disk contents! let mint = m.position saveRodFile(toRodFile(g.config, AbsoluteFile toFullPath(g.config, FileIndex(mint))), - g.encoders[mint], g.packed[mint].fromDisk) + g.encoders[mint], g.packed[mint].toDisk) g.packed[mint].status = stored elif g.config.symbolFiles == stressTest: # debug code, but maybe a good idea for production? Could reduce the compiler's # memory consumption considerably at the cost of more loads from disk. let mint = m.position - simulateCachedModule(g, m, g.packed[mint].fromDisk) + simulateCachedModule(g, m, g.packed[mint].toDisk) g.packed[mint].status = loaded proc dependsOn(a, b: int): int {.inline.} = (a shl 15) + b diff --git a/compiler/semdata.nim b/compiler/semdata.nim index 12930fecad19..2c05f8348606 100644 --- a/compiler/semdata.nim +++ b/compiler/semdata.nim @@ -331,7 +331,7 @@ proc newContext*(graph: ModuleGraph; module: PSym): PContext = graph.packed[id].module = module initEncoder graph, module -template packedRepr*(c): untyped = c.graph.packed[c.module.position].fromDisk +template packedRepr*(c): untyped = c.graph.packed[c.module.position].toDisk template encoder*(c): untyped = c.graph.encoders[c.module.position] proc addIncludeFileDep*(c: PContext; f: FileIndex) =