vmgen.nim 78 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325
  1. #
  2. #
  3. # The Nim Compiler
  4. # (c) Copyright 2015 Andreas Rumpf
  5. #
  6. # See the file "copying.txt", included in this
  7. # distribution, for details about the copyright.
  8. #
  9. ## This module implements the code generator for the VM.
  10. # Important things to remember:
  11. # - The VM does not distinguish between definitions ('var x = y') and
  12. # assignments ('x = y'). For simple data types that fit into a register
  13. # this doesn't matter. However it matters for strings and other complex
  14. # types that use the 'node' field; the reason is that slots are
  15. # re-used in a register based VM. Example:
  16. # ```nim
  17. # let s = a & b # no matter what, create fresh node
  18. # s = a & b # no matter what, keep the node
  19. # ```
  20. # Also *stores* into non-temporary memory need to perform deep copies:
  21. # a.b = x.y
  22. # We used to generate opcAsgn for the *load* of 'x.y' but this is clearly
  23. # wrong! We need to produce opcAsgn (the copy) for the *store*. This also
  24. # solves the opcLdConst vs opcAsgnConst issue. Of course whether we need
  25. # this copy depends on the involved types.
  26. import tables
  27. when defined(nimPreviewSlimSystem):
  28. import std/assertions
  29. import
  30. strutils, ast, types, msgs, renderer, vmdef,
  31. intsets, magicsys, options, lowerings, lineinfos, transf, astmsgs
  32. from modulegraphs import getBody
  33. when defined(nimCompilerStacktraceHints):
  34. import std/stackframes
  35. const
  36. debugEchoCode* = defined(nimVMDebug)
  37. when debugEchoCode:
  38. import std/private/asciitables
  39. when hasFFI:
  40. import evalffi
  41. type
  42. TGenFlag = enum
  43. gfNode # Affects how variables are loaded - always loads as rkNode
  44. gfNodeAddr # Affects how variables are loaded - always loads as rkNodeAddr
  45. gfIsParam # do not deepcopy parameters, they are immutable
  46. TGenFlags = set[TGenFlag]
  47. proc debugInfo(c: PCtx; info: TLineInfo): string =
  48. result = toFileLineCol(c.config, info)
  49. proc codeListing(c: PCtx, result: var string, start=0; last = -1) =
  50. ## for debugging purposes
  51. # first iteration: compute all necessary labels:
  52. var jumpTargets = initIntSet()
  53. let last = if last < 0: c.code.len-1 else: min(last, c.code.len-1)
  54. for i in start..last:
  55. let x = c.code[i]
  56. if x.opcode in relativeJumps:
  57. jumpTargets.incl(i+x.regBx-wordExcess)
  58. template toStr(opc: TOpcode): string = ($opc).substr(3)
  59. result.add "code listing:\n"
  60. var i = start
  61. while i <= last:
  62. if i in jumpTargets: result.addf("L$1:\n", i)
  63. let x = c.code[i]
  64. result.add($i)
  65. let opc = opcode(x)
  66. if opc in {opcIndCall, opcIndCallAsgn}:
  67. result.addf("\t$#\tr$#, r$#, nargs:$#", opc.toStr, x.regA,
  68. x.regB, x.regC)
  69. elif opc in {opcConv, opcCast}:
  70. let y = c.code[i+1]
  71. let z = c.code[i+2]
  72. result.addf("\t$#\tr$#, r$#, $#, $#", opc.toStr, x.regA, x.regB,
  73. c.types[y.regBx-wordExcess].typeToString,
  74. c.types[z.regBx-wordExcess].typeToString)
  75. inc i, 2
  76. elif opc < firstABxInstr:
  77. result.addf("\t$#\tr$#, r$#, r$#", opc.toStr, x.regA,
  78. x.regB, x.regC)
  79. elif opc in relativeJumps + {opcTry}:
  80. result.addf("\t$#\tr$#, L$#", opc.toStr, x.regA,
  81. i+x.regBx-wordExcess)
  82. elif opc in {opcExcept}:
  83. let idx = x.regBx-wordExcess
  84. result.addf("\t$#\t$#, $#", opc.toStr, x.regA, $idx)
  85. elif opc in {opcLdConst, opcAsgnConst}:
  86. let idx = x.regBx-wordExcess
  87. result.addf("\t$#\tr$#, $# ($#)", opc.toStr, x.regA,
  88. c.constants[idx].renderTree, $idx)
  89. else:
  90. result.addf("\t$#\tr$#, $#", opc.toStr, x.regA, x.regBx-wordExcess)
  91. result.add("\t# ")
  92. result.add(debugInfo(c, c.debug[i]))
  93. result.add("\n")
  94. inc i
  95. when debugEchoCode:
  96. result = result.alignTable
  97. proc echoCode*(c: PCtx; start=0; last = -1) {.deprecated.} =
  98. var buf = ""
  99. codeListing(c, buf, start, last)
  100. echo buf
  101. proc gABC(ctx: PCtx; n: PNode; opc: TOpcode; a, b, c: TRegister = 0) =
  102. ## Takes the registers `b` and `c`, applies the operation `opc` to them, and
  103. ## stores the result into register `a`
  104. ## The node is needed for debug information
  105. assert opc.ord < 255
  106. let ins = (opc.TInstrType or (a.TInstrType shl regAShift) or
  107. (b.TInstrType shl regBShift) or
  108. (c.TInstrType shl regCShift)).TInstr
  109. when false:
  110. if ctx.code.len == 43:
  111. writeStackTrace()
  112. echo "generating ", opc
  113. ctx.code.add(ins)
  114. ctx.debug.add(n.info)
  115. proc gABI(c: PCtx; n: PNode; opc: TOpcode; a, b: TRegister; imm: BiggestInt) =
  116. # Takes the `b` register and the immediate `imm`, applies the operation `opc`,
  117. # and stores the output value into `a`.
  118. # `imm` is signed and must be within [-128, 127]
  119. if imm >= -128 and imm <= 127:
  120. let ins = (opc.TInstrType or (a.TInstrType shl regAShift) or
  121. (b.TInstrType shl regBShift) or
  122. (imm+byteExcess).TInstrType shl regCShift).TInstr
  123. c.code.add(ins)
  124. c.debug.add(n.info)
  125. else:
  126. localError(c.config, n.info,
  127. "VM: immediate value does not fit into an int8")
  128. proc gABx(c: PCtx; n: PNode; opc: TOpcode; a: TRegister = 0; bx: int) =
  129. # Applies `opc` to `bx` and stores it into register `a`
  130. # `bx` must be signed and in the range [regBxMin, regBxMax]
  131. when false:
  132. if c.code.len == 43:
  133. writeStackTrace()
  134. echo "generating ", opc
  135. if bx >= regBxMin-1 and bx <= regBxMax:
  136. let ins = (opc.TInstrType or a.TInstrType shl regAShift or
  137. (bx+wordExcess).TInstrType shl regBxShift).TInstr
  138. c.code.add(ins)
  139. c.debug.add(n.info)
  140. else:
  141. localError(c.config, n.info,
  142. "VM: immediate value does not fit into regBx")
  143. proc xjmp(c: PCtx; n: PNode; opc: TOpcode; a: TRegister = 0): TPosition =
  144. #assert opc in {opcJmp, opcFJmp, opcTJmp}
  145. result = TPosition(c.code.len)
  146. gABx(c, n, opc, a, 0)
  147. proc genLabel(c: PCtx): TPosition =
  148. result = TPosition(c.code.len)
  149. #c.jumpTargets.incl(c.code.len)
  150. proc jmpBack(c: PCtx, n: PNode, p = TPosition(0)) =
  151. let dist = p.int - c.code.len
  152. internalAssert(c.config, regBxMin < dist and dist < regBxMax)
  153. gABx(c, n, opcJmpBack, 0, dist)
  154. proc patch(c: PCtx, p: TPosition) =
  155. # patch with current index
  156. let p = p.int
  157. let diff = c.code.len - p
  158. #c.jumpTargets.incl(c.code.len)
  159. internalAssert(c.config, regBxMin < diff and diff < regBxMax)
  160. let oldInstr = c.code[p]
  161. # opcode and regA stay the same:
  162. c.code[p] = ((oldInstr.TInstrType and regBxMask).TInstrType or
  163. TInstrType(diff+wordExcess) shl regBxShift).TInstr
  164. proc getSlotKind(t: PType): TSlotKind =
  165. case t.skipTypes(abstractRange-{tyTypeDesc}).kind
  166. of tyBool, tyChar, tyEnum, tyOrdinal, tyInt..tyInt64, tyUInt..tyUInt64:
  167. slotTempInt
  168. of tyString, tyCstring:
  169. slotTempStr
  170. of tyFloat..tyFloat128:
  171. slotTempFloat
  172. else:
  173. slotTempComplex
  174. const
  175. HighRegisterPressure = 40
  176. proc bestEffort(c: PCtx): TLineInfo =
  177. if c.prc != nil and c.prc.sym != nil:
  178. c.prc.sym.info
  179. else:
  180. c.module.info
  181. proc getFreeRegister(cc: PCtx; k: TSlotKind; start: int): TRegister =
  182. let c = cc.prc
  183. # we prefer the same slot kind here for efficiency. Unfortunately for
  184. # discardable return types we may not know the desired type. This can happen
  185. # for e.g. mNAdd[Multiple]:
  186. for i in start..c.regInfo.len-1:
  187. if c.regInfo[i].kind == k and not c.regInfo[i].inUse:
  188. c.regInfo[i].inUse = true
  189. return TRegister(i)
  190. # if register pressure is high, we re-use more aggressively:
  191. if c.regInfo.len >= high(TRegister):
  192. for i in start..c.regInfo.len-1:
  193. if not c.regInfo[i].inUse:
  194. c.regInfo[i] = (inUse: true, kind: k)
  195. return TRegister(i)
  196. if c.regInfo.len >= high(TRegister):
  197. globalError(cc.config, cc.bestEffort, "VM problem: too many registers required")
  198. result = TRegister(max(c.regInfo.len, start))
  199. c.regInfo.setLen int(result)+1
  200. c.regInfo[result] = (inUse: true, kind: k)
  201. proc getTemp(cc: PCtx; tt: PType): TRegister =
  202. let typ = tt.skipTypesOrNil({tyStatic})
  203. # we prefer the same slot kind here for efficiency. Unfortunately for
  204. # discardable return types we may not know the desired type. This can happen
  205. # for e.g. mNAdd[Multiple]:
  206. let k = if typ.isNil: slotTempComplex else: typ.getSlotKind
  207. result = getFreeRegister(cc, k, start = 0)
  208. when false:
  209. # enable this to find "register" leaks:
  210. if result == 4:
  211. echo "begin ---------------"
  212. writeStackTrace()
  213. echo "end ----------------"
  214. proc freeTemp(c: PCtx; r: TRegister) =
  215. let c = c.prc
  216. if c.regInfo[r].kind in {slotSomeTemp..slotTempComplex}:
  217. # this seems to cause https://github.com/nim-lang/Nim/issues/10647
  218. c.regInfo[r].inUse = false
  219. proc getTempRange(cc: PCtx; n: int; kind: TSlotKind): TRegister =
  220. # if register pressure is high, we re-use more aggressively:
  221. let c = cc.prc
  222. # we could also customize via the following (with proper caching in ConfigRef):
  223. # let highRegisterPressure = cc.config.getConfigVar("vm.highRegisterPressure", "40").parseInt
  224. if c.regInfo.len >= HighRegisterPressure or c.regInfo.len+n >= high(TRegister):
  225. for i in 0..c.regInfo.len-n:
  226. if not c.regInfo[i].inUse:
  227. block search:
  228. for j in i+1..i+n-1:
  229. if c.regInfo[j].inUse: break search
  230. result = TRegister(i)
  231. for k in result..result+n-1: c.regInfo[k] = (inUse: true, kind: kind)
  232. return
  233. if c.regInfo.len+n >= high(TRegister):
  234. globalError(cc.config, cc.bestEffort, "VM problem: too many registers required")
  235. result = TRegister(c.regInfo.len)
  236. setLen c.regInfo, c.regInfo.len+n
  237. for k in result..result+n-1: c.regInfo[k] = (inUse: true, kind: kind)
  238. proc freeTempRange(c: PCtx; start: TRegister, n: int) =
  239. for i in start..start+n-1: c.freeTemp(TRegister(i))
  240. template withTemp(tmp, typ, body: untyped) {.dirty.} =
  241. var tmp = getTemp(c, typ)
  242. body
  243. c.freeTemp(tmp)
  244. proc popBlock(c: PCtx; oldLen: int) =
  245. for f in c.prc.blocks[oldLen].fixups:
  246. c.patch(f)
  247. c.prc.blocks.setLen(oldLen)
  248. template withBlock(labl: PSym; body: untyped) {.dirty.} =
  249. var oldLen {.gensym.} = c.prc.blocks.len
  250. c.prc.blocks.add TBlock(label: labl, fixups: @[])
  251. body
  252. popBlock(c, oldLen)
  253. proc gen(c: PCtx; n: PNode; dest: var TDest; flags: TGenFlags = {})
  254. proc gen(c: PCtx; n: PNode; dest: TRegister; flags: TGenFlags = {}) =
  255. var d: TDest = dest
  256. gen(c, n, d, flags)
  257. #internalAssert c.config, d == dest # issue #7407
  258. proc gen(c: PCtx; n: PNode; flags: TGenFlags = {}) =
  259. var tmp: TDest = -1
  260. gen(c, n, tmp, flags)
  261. if tmp >= 0:
  262. freeTemp(c, tmp)
  263. #if n.typ.isEmptyType: internalAssert tmp < 0
  264. proc genx(c: PCtx; n: PNode; flags: TGenFlags = {}): TRegister =
  265. var tmp: TDest = -1
  266. gen(c, n, tmp, flags)
  267. #internalAssert c.config, tmp >= 0 # 'nim check' does not like this internalAssert.
  268. if tmp >= 0:
  269. result = TRegister(tmp)
  270. proc clearDest(c: PCtx; n: PNode; dest: var TDest) {.inline.} =
  271. # stmt is different from 'void' in meta programming contexts.
  272. # So we only set dest to -1 if 'void':
  273. if dest >= 0 and (n.typ.isNil or n.typ.kind == tyVoid):
  274. c.freeTemp(dest)
  275. dest = -1
  276. proc isNotOpr(n: PNode): bool =
  277. n.kind in nkCallKinds and n[0].kind == nkSym and
  278. n[0].sym.magic == mNot
  279. proc isTrue(n: PNode): bool =
  280. n.kind == nkSym and n.sym.kind == skEnumField and n.sym.position != 0 or
  281. n.kind == nkIntLit and n.intVal != 0
  282. proc genWhile(c: PCtx; n: PNode) =
  283. # lab1:
  284. # cond, tmp
  285. # fjmp tmp, lab2
  286. # body
  287. # jmp lab1
  288. # lab2:
  289. let lab1 = c.genLabel
  290. withBlock(nil):
  291. if isTrue(n[0]):
  292. c.gen(n[1])
  293. c.jmpBack(n, lab1)
  294. elif isNotOpr(n[0]):
  295. var tmp = c.genx(n[0][1])
  296. let lab2 = c.xjmp(n, opcTJmp, tmp)
  297. c.freeTemp(tmp)
  298. c.gen(n[1])
  299. c.jmpBack(n, lab1)
  300. c.patch(lab2)
  301. else:
  302. var tmp = c.genx(n[0])
  303. let lab2 = c.xjmp(n, opcFJmp, tmp)
  304. c.freeTemp(tmp)
  305. c.gen(n[1])
  306. c.jmpBack(n, lab1)
  307. c.patch(lab2)
  308. proc genBlock(c: PCtx; n: PNode; dest: var TDest) =
  309. let oldRegisterCount = c.prc.regInfo.len
  310. withBlock(n[0].sym):
  311. c.gen(n[1], dest)
  312. for i in oldRegisterCount..<c.prc.regInfo.len:
  313. #if c.prc.regInfo[i].kind in {slotFixedVar, slotFixedLet}:
  314. if i != dest:
  315. when not defined(release):
  316. if c.prc.regInfo[i].inUse and c.prc.regInfo[i].kind in {slotTempUnknown,
  317. slotTempInt,
  318. slotTempFloat,
  319. slotTempStr,
  320. slotTempComplex}:
  321. doAssert false, "leaking temporary " & $i & " " & $c.prc.regInfo[i].kind
  322. c.prc.regInfo[i] = (inUse: false, kind: slotEmpty)
  323. c.clearDest(n, dest)
  324. proc genBreak(c: PCtx; n: PNode) =
  325. let lab1 = c.xjmp(n, opcJmp)
  326. if n[0].kind == nkSym:
  327. #echo cast[int](n[0].sym)
  328. for i in countdown(c.prc.blocks.len-1, 0):
  329. if c.prc.blocks[i].label == n[0].sym:
  330. c.prc.blocks[i].fixups.add lab1
  331. return
  332. globalError(c.config, n.info, "VM problem: cannot find 'break' target")
  333. else:
  334. c.prc.blocks[c.prc.blocks.high].fixups.add lab1
  335. proc genIf(c: PCtx, n: PNode; dest: var TDest) =
  336. # if (!expr1) goto lab1;
  337. # thenPart
  338. # goto LEnd
  339. # lab1:
  340. # if (!expr2) goto lab2;
  341. # thenPart2
  342. # goto LEnd
  343. # lab2:
  344. # elsePart
  345. # Lend:
  346. if dest < 0 and not isEmptyType(n.typ): dest = getTemp(c, n.typ)
  347. var endings: seq[TPosition] = @[]
  348. for i in 0..<n.len:
  349. var it = n[i]
  350. if it.len == 2:
  351. withTemp(tmp, it[0].typ):
  352. var elsePos: TPosition
  353. if isNotOpr(it[0]):
  354. c.gen(it[0][1], tmp)
  355. elsePos = c.xjmp(it[0][1], opcTJmp, tmp) # if true
  356. else:
  357. c.gen(it[0], tmp)
  358. elsePos = c.xjmp(it[0], opcFJmp, tmp) # if false
  359. c.clearDest(n, dest)
  360. c.gen(it[1], dest) # then part
  361. if i < n.len-1:
  362. endings.add(c.xjmp(it[1], opcJmp, 0))
  363. c.patch(elsePos)
  364. else:
  365. c.clearDest(n, dest)
  366. c.gen(it[0], dest)
  367. for endPos in endings: c.patch(endPos)
  368. c.clearDest(n, dest)
  369. proc isTemp(c: PCtx; dest: TDest): bool =
  370. result = dest >= 0 and c.prc.regInfo[dest].kind >= slotTempUnknown
  371. proc genAndOr(c: PCtx; n: PNode; opc: TOpcode; dest: var TDest) =
  372. # asgn dest, a
  373. # tjmp|fjmp lab1
  374. # asgn dest, b
  375. # lab1:
  376. let copyBack = dest < 0 or not isTemp(c, dest)
  377. let tmp = if copyBack:
  378. getTemp(c, n.typ)
  379. else:
  380. TRegister dest
  381. c.gen(n[1], tmp)
  382. let lab1 = c.xjmp(n, opc, tmp)
  383. c.gen(n[2], tmp)
  384. c.patch(lab1)
  385. if dest < 0:
  386. dest = tmp
  387. elif copyBack:
  388. c.gABC(n, opcAsgnInt, dest, tmp)
  389. freeTemp(c, tmp)
  390. proc rawGenLiteral(c: PCtx; n: PNode): int =
  391. result = c.constants.len
  392. #assert(n.kind != nkCall)
  393. n.flags.incl nfAllConst
  394. c.constants.add n
  395. internalAssert c.config, result < regBxMax
  396. proc sameConstant*(a, b: PNode): bool =
  397. result = false
  398. if a == b:
  399. result = true
  400. elif a != nil and b != nil and a.kind == b.kind:
  401. case a.kind
  402. of nkSym: result = a.sym == b.sym
  403. of nkIdent: result = a.ident.id == b.ident.id
  404. of nkCharLit..nkUInt64Lit: result = a.intVal == b.intVal
  405. of nkFloatLit..nkFloat64Lit:
  406. result = cast[uint64](a.floatVal) == cast[uint64](b.floatVal)
  407. # refs bug #16469
  408. # if we wanted to only distinguish 0.0 vs -0.0:
  409. # if a.floatVal == 0.0: result = cast[uint64](a.floatVal) == cast[uint64](b.floatVal)
  410. # else: result = a.floatVal == b.floatVal
  411. of nkStrLit..nkTripleStrLit: result = a.strVal == b.strVal
  412. of nkType, nkNilLit: result = a.typ == b.typ
  413. of nkEmpty: result = true
  414. else:
  415. if a.len == b.len:
  416. for i in 0..<a.len:
  417. if not sameConstant(a[i], b[i]): return
  418. result = true
  419. proc genLiteral(c: PCtx; n: PNode): int =
  420. # types do not matter here:
  421. for i in 0..<c.constants.len:
  422. if sameConstant(c.constants[i], n): return i
  423. result = rawGenLiteral(c, n)
  424. proc unused(c: PCtx; n: PNode; x: TDest) {.inline.} =
  425. if x >= 0:
  426. #debug(n)
  427. globalError(c.config, n.info, "not unused")
  428. proc genCase(c: PCtx; n: PNode; dest: var TDest) =
  429. # if (!expr1) goto lab1;
  430. # thenPart
  431. # goto LEnd
  432. # lab1:
  433. # if (!expr2) goto lab2;
  434. # thenPart2
  435. # goto LEnd
  436. # lab2:
  437. # elsePart
  438. # Lend:
  439. if not isEmptyType(n.typ):
  440. if dest < 0: dest = getTemp(c, n.typ)
  441. else:
  442. unused(c, n, dest)
  443. var endings: seq[TPosition] = @[]
  444. withTemp(tmp, n[0].typ):
  445. c.gen(n[0], tmp)
  446. # branch tmp, codeIdx
  447. # fjmp elseLabel
  448. for i in 1..<n.len:
  449. let it = n[i]
  450. if it.len == 1:
  451. # else stmt:
  452. if it[0].kind != nkNilLit or it[0].typ != nil:
  453. # an nkNilLit with nil for typ implies there is no else branch, this
  454. # avoids unused related errors as we've already consumed the dest
  455. c.gen(it[0], dest)
  456. else:
  457. let b = rawGenLiteral(c, it)
  458. c.gABx(it, opcBranch, tmp, b)
  459. let elsePos = c.xjmp(it.lastSon, opcFJmp, tmp)
  460. c.gen(it.lastSon, dest)
  461. if i < n.len-1:
  462. endings.add(c.xjmp(it.lastSon, opcJmp, 0))
  463. c.patch(elsePos)
  464. c.clearDest(n, dest)
  465. for endPos in endings: c.patch(endPos)
  466. proc genType(c: PCtx; typ: PType): int =
  467. for i, t in c.types:
  468. if sameType(t, typ): return i
  469. result = c.types.len
  470. c.types.add(typ)
  471. internalAssert(c.config, result <= regBxMax)
  472. proc genTry(c: PCtx; n: PNode; dest: var TDest) =
  473. if dest < 0 and not isEmptyType(n.typ): dest = getTemp(c, n.typ)
  474. var endings: seq[TPosition] = @[]
  475. let ehPos = c.xjmp(n, opcTry, 0)
  476. c.gen(n[0], dest)
  477. c.clearDest(n, dest)
  478. # Add a jump past the exception handling code
  479. let jumpToFinally = c.xjmp(n, opcJmp, 0)
  480. # This signals where the body ends and where the exception handling begins
  481. c.patch(ehPos)
  482. for i in 1..<n.len:
  483. let it = n[i]
  484. if it.kind != nkFinally:
  485. # first opcExcept contains the end label of the 'except' block:
  486. let endExcept = c.xjmp(it, opcExcept, 0)
  487. for j in 0..<it.len - 1:
  488. assert(it[j].kind == nkType)
  489. let typ = it[j].typ.skipTypes(abstractPtrs-{tyTypeDesc})
  490. c.gABx(it, opcExcept, 0, c.genType(typ))
  491. if it.len == 1:
  492. # general except section:
  493. c.gABx(it, opcExcept, 0, 0)
  494. c.gen(it.lastSon, dest)
  495. c.clearDest(n, dest)
  496. if i < n.len:
  497. endings.add(c.xjmp(it, opcJmp, 0))
  498. c.patch(endExcept)
  499. let fin = lastSon(n)
  500. # we always generate an 'opcFinally' as that pops the safepoint
  501. # from the stack if no exception is raised in the body.
  502. c.patch(jumpToFinally)
  503. c.gABx(fin, opcFinally, 0, 0)
  504. for endPos in endings: c.patch(endPos)
  505. if fin.kind == nkFinally:
  506. c.gen(fin[0])
  507. c.clearDest(n, dest)
  508. c.gABx(fin, opcFinallyEnd, 0, 0)
  509. proc genRaise(c: PCtx; n: PNode) =
  510. let dest = genx(c, n[0])
  511. c.gABC(n, opcRaise, dest)
  512. c.freeTemp(dest)
  513. proc genReturn(c: PCtx; n: PNode) =
  514. if n[0].kind != nkEmpty:
  515. gen(c, n[0])
  516. c.gABC(n, opcRet)
  517. proc genLit(c: PCtx; n: PNode; dest: var TDest) =
  518. # opcLdConst is now always valid. We produce the necessary copy in the
  519. # assignments now:
  520. #var opc = opcLdConst
  521. if dest < 0: dest = c.getTemp(n.typ)
  522. #elif c.prc.regInfo[dest].kind == slotFixedVar: opc = opcAsgnConst
  523. let lit = genLiteral(c, n)
  524. c.gABx(n, opcLdConst, dest, lit)
  525. proc genCall(c: PCtx; n: PNode; dest: var TDest) =
  526. # it can happen that due to inlining we have a 'n' that should be
  527. # treated as a constant (see issue #537).
  528. #if n.typ != nil and n.typ.sym != nil and n.typ.sym.magic == mPNimrodNode:
  529. # genLit(c, n, dest)
  530. # return
  531. # bug #10901: do not produce code for wrong call expressions:
  532. if n.len == 0 or n[0].typ.isNil: return
  533. if dest < 0 and not isEmptyType(n.typ): dest = getTemp(c, n.typ)
  534. let x = c.getTempRange(n.len, slotTempUnknown)
  535. # varargs need 'opcSetType' for the FFI support:
  536. let fntyp = skipTypes(n[0].typ, abstractInst)
  537. for i in 0..<n.len:
  538. var r: TRegister = x+i
  539. c.gen(n[i], r, {gfIsParam})
  540. if i >= fntyp.len:
  541. internalAssert c.config, tfVarargs in fntyp.flags
  542. c.gABx(n, opcSetType, r, c.genType(n[i].typ))
  543. if dest < 0:
  544. c.gABC(n, opcIndCall, 0, x, n.len)
  545. else:
  546. c.gABC(n, opcIndCallAsgn, dest, x, n.len)
  547. c.freeTempRange(x, n.len)
  548. template isGlobal(s: PSym): bool = sfGlobal in s.flags and s.kind != skForVar
  549. proc isGlobal(n: PNode): bool = n.kind == nkSym and isGlobal(n.sym)
  550. proc needsAsgnPatch(n: PNode): bool =
  551. n.kind in {nkBracketExpr, nkDotExpr, nkCheckedFieldExpr,
  552. nkDerefExpr, nkHiddenDeref} or (n.kind == nkSym and n.sym.isGlobal)
  553. proc genField(c: PCtx; n: PNode): TRegister =
  554. if n.kind != nkSym or n.sym.kind != skField:
  555. globalError(c.config, n.info, "no field symbol")
  556. let s = n.sym
  557. if s.position > high(typeof(result)):
  558. globalError(c.config, n.info,
  559. "too large offset! cannot generate code for: " & s.name.s)
  560. result = s.position
  561. proc genIndex(c: PCtx; n: PNode; arr: PType): TRegister =
  562. if arr.skipTypes(abstractInst).kind == tyArray and (let x = firstOrd(c.config, arr);
  563. x != Zero):
  564. let tmp = c.genx(n)
  565. # freeing the temporary here means we can produce: regA = regA - Imm
  566. c.freeTemp(tmp)
  567. result = c.getTemp(n.typ)
  568. c.gABI(n, opcSubImmInt, result, tmp, toInt(x))
  569. else:
  570. result = c.genx(n)
  571. proc genCheckedObjAccessAux(c: PCtx; n: PNode; dest: var TDest; flags: TGenFlags)
  572. proc genAsgnPatch(c: PCtx; le: PNode, value: TRegister) =
  573. case le.kind
  574. of nkBracketExpr:
  575. let
  576. dest = c.genx(le[0], {gfNode})
  577. idx = c.genIndex(le[1], le[0].typ)
  578. collTyp = le[0].typ.skipTypes(abstractVarRange-{tyTypeDesc})
  579. case collTyp.kind
  580. of tyString, tyCstring:
  581. c.gABC(le, opcWrStrIdx, dest, idx, value)
  582. of tyTuple:
  583. c.gABC(le, opcWrObj, dest, int le[1].intVal, value)
  584. else:
  585. c.gABC(le, opcWrArr, dest, idx, value)
  586. c.freeTemp(dest)
  587. c.freeTemp(idx)
  588. of nkCheckedFieldExpr:
  589. var objR: TDest = -1
  590. genCheckedObjAccessAux(c, le, objR, {gfNode})
  591. let idx = genField(c, le[0][1])
  592. c.gABC(le[0], opcWrObj, objR, idx, value)
  593. c.freeTemp(objR)
  594. of nkDotExpr:
  595. let dest = c.genx(le[0], {gfNode})
  596. let idx = genField(c, le[1])
  597. c.gABC(le, opcWrObj, dest, idx, value)
  598. c.freeTemp(dest)
  599. of nkDerefExpr, nkHiddenDeref:
  600. let dest = c.genx(le[0], {gfNode})
  601. c.gABC(le, opcWrDeref, dest, 0, value)
  602. c.freeTemp(dest)
  603. of nkSym:
  604. if le.sym.isGlobal:
  605. let dest = c.genx(le, {gfNodeAddr})
  606. c.gABC(le, opcWrDeref, dest, 0, value)
  607. c.freeTemp(dest)
  608. else:
  609. discard
  610. proc genNew(c: PCtx; n: PNode) =
  611. let dest = if needsAsgnPatch(n[1]): c.getTemp(n[1].typ)
  612. else: c.genx(n[1])
  613. # we use the ref's base type here as the VM conflates 'ref object'
  614. # and 'object' since internally we already have a pointer.
  615. c.gABx(n, opcNew, dest,
  616. c.genType(n[1].typ.skipTypes(abstractVar-{tyTypeDesc})[0]))
  617. c.genAsgnPatch(n[1], dest)
  618. c.freeTemp(dest)
  619. proc genNewSeq(c: PCtx; n: PNode) =
  620. let t = n[1].typ
  621. let dest = if needsAsgnPatch(n[1]): c.getTemp(t)
  622. else: c.genx(n[1])
  623. let tmp = c.genx(n[2])
  624. c.gABx(n, opcNewSeq, dest, c.genType(t.skipTypes(
  625. abstractVar-{tyTypeDesc})))
  626. c.gABx(n, opcNewSeq, tmp, 0)
  627. c.freeTemp(tmp)
  628. c.genAsgnPatch(n[1], dest)
  629. c.freeTemp(dest)
  630. proc genNewSeqOfCap(c: PCtx; n: PNode; dest: var TDest) =
  631. let t = n.typ
  632. if dest < 0:
  633. dest = c.getTemp(n.typ)
  634. let tmp = c.getTemp(n[1].typ)
  635. c.gABx(n, opcLdNull, dest, c.genType(t))
  636. c.gABx(n, opcLdImmInt, tmp, 0)
  637. c.gABx(n, opcNewSeq, dest, c.genType(t.skipTypes(
  638. abstractVar-{tyTypeDesc})))
  639. c.gABx(n, opcNewSeq, tmp, 0)
  640. c.freeTemp(tmp)
  641. proc genUnaryABC(c: PCtx; n: PNode; dest: var TDest; opc: TOpcode) =
  642. let tmp = c.genx(n[1])
  643. if dest < 0: dest = c.getTemp(n.typ)
  644. c.gABC(n, opc, dest, tmp)
  645. c.freeTemp(tmp)
  646. proc genUnaryABI(c: PCtx; n: PNode; dest: var TDest; opc: TOpcode; imm: BiggestInt=0) =
  647. let tmp = c.genx(n[1])
  648. if dest < 0: dest = c.getTemp(n.typ)
  649. c.gABI(n, opc, dest, tmp, imm)
  650. c.freeTemp(tmp)
  651. proc genBinaryABC(c: PCtx; n: PNode; dest: var TDest; opc: TOpcode) =
  652. let
  653. tmp = c.genx(n[1])
  654. tmp2 = c.genx(n[2])
  655. if dest < 0: dest = c.getTemp(n.typ)
  656. c.gABC(n, opc, dest, tmp, tmp2)
  657. c.freeTemp(tmp)
  658. c.freeTemp(tmp2)
  659. proc genBinaryABCD(c: PCtx; n: PNode; dest: var TDest; opc: TOpcode) =
  660. let
  661. tmp = c.genx(n[1])
  662. tmp2 = c.genx(n[2])
  663. tmp3 = c.genx(n[3])
  664. if dest < 0: dest = c.getTemp(n.typ)
  665. c.gABC(n, opc, dest, tmp, tmp2)
  666. c.gABC(n, opc, tmp3)
  667. c.freeTemp(tmp)
  668. c.freeTemp(tmp2)
  669. c.freeTemp(tmp3)
  670. template sizeOfLikeMsg(name): string =
  671. "'$1' requires '.importc' types to be '.completeStruct'" % [name]
  672. proc genNarrow(c: PCtx; n: PNode; dest: TDest) =
  673. let t = skipTypes(n.typ, abstractVar-{tyTypeDesc})
  674. # uint is uint64 in the VM, we we only need to mask the result for
  675. # other unsigned types:
  676. let size = getSize(c.config, t)
  677. if t.kind in {tyUInt8..tyUInt32} or (t.kind == tyUInt and size < 8):
  678. c.gABC(n, opcNarrowU, dest, TRegister(size*8))
  679. elif t.kind in {tyInt8..tyInt32} or (t.kind == tyInt and size < 8):
  680. c.gABC(n, opcNarrowS, dest, TRegister(size*8))
  681. proc genNarrowU(c: PCtx; n: PNode; dest: TDest) =
  682. let t = skipTypes(n.typ, abstractVar-{tyTypeDesc})
  683. # uint is uint64 in the VM, we we only need to mask the result for
  684. # other unsigned types:
  685. let size = getSize(c.config, t)
  686. if t.kind in {tyUInt8..tyUInt32, tyInt8..tyInt32} or
  687. (t.kind in {tyUInt, tyInt} and size < 8):
  688. c.gABC(n, opcNarrowU, dest, TRegister(size*8))
  689. proc genBinaryABCnarrow(c: PCtx; n: PNode; dest: var TDest; opc: TOpcode) =
  690. genBinaryABC(c, n, dest, opc)
  691. genNarrow(c, n, dest)
  692. proc genBinaryABCnarrowU(c: PCtx; n: PNode; dest: var TDest; opc: TOpcode) =
  693. genBinaryABC(c, n, dest, opc)
  694. genNarrowU(c, n, dest)
  695. proc genSetType(c: PCtx; n: PNode; dest: TRegister) =
  696. let t = skipTypes(n.typ, abstractInst-{tyTypeDesc})
  697. if t.kind == tySet:
  698. c.gABx(n, opcSetType, dest, c.genType(t))
  699. proc genBinarySet(c: PCtx; n: PNode; dest: var TDest; opc: TOpcode) =
  700. let
  701. tmp = c.genx(n[1])
  702. tmp2 = c.genx(n[2])
  703. if dest < 0: dest = c.getTemp(n.typ)
  704. c.genSetType(n[1], tmp)
  705. c.genSetType(n[2], tmp2)
  706. c.gABC(n, opc, dest, tmp, tmp2)
  707. c.freeTemp(tmp)
  708. c.freeTemp(tmp2)
  709. proc genBinaryStmt(c: PCtx; n: PNode; opc: TOpcode) =
  710. let
  711. dest = c.genx(n[1])
  712. tmp = c.genx(n[2])
  713. c.gABC(n, opc, dest, tmp, 0)
  714. c.freeTemp(tmp)
  715. c.freeTemp(dest)
  716. proc genBinaryStmtVar(c: PCtx; n: PNode; opc: TOpcode) =
  717. var x = n[1]
  718. if x.kind in {nkAddr, nkHiddenAddr}: x = x[0]
  719. let
  720. dest = c.genx(x)
  721. tmp = c.genx(n[2])
  722. c.gABC(n, opc, dest, tmp, 0)
  723. #c.genAsgnPatch(n[1], dest)
  724. c.freeTemp(tmp)
  725. c.freeTemp(dest)
  726. proc genUnaryStmt(c: PCtx; n: PNode; opc: TOpcode) =
  727. let tmp = c.genx(n[1])
  728. c.gABC(n, opc, tmp, 0, 0)
  729. c.freeTemp(tmp)
  730. proc genVarargsABC(c: PCtx; n: PNode; dest: var TDest; opc: TOpcode) =
  731. if dest < 0: dest = getTemp(c, n.typ)
  732. var x = c.getTempRange(n.len-1, slotTempStr)
  733. for i in 1..<n.len:
  734. var r: TRegister = x+i-1
  735. c.gen(n[i], r)
  736. c.gABC(n, opc, dest, x, n.len-1)
  737. c.freeTempRange(x, n.len-1)
  738. proc isInt8Lit(n: PNode): bool =
  739. if n.kind in {nkCharLit..nkUInt64Lit}:
  740. result = n.intVal >= low(int8) and n.intVal <= high(int8)
  741. proc isInt16Lit(n: PNode): bool =
  742. if n.kind in {nkCharLit..nkUInt64Lit}:
  743. result = n.intVal >= low(int16) and n.intVal <= high(int16)
  744. proc genAddSubInt(c: PCtx; n: PNode; dest: var TDest; opc: TOpcode) =
  745. if n[2].isInt8Lit:
  746. let tmp = c.genx(n[1])
  747. if dest < 0: dest = c.getTemp(n.typ)
  748. c.gABI(n, succ(opc), dest, tmp, n[2].intVal)
  749. c.freeTemp(tmp)
  750. else:
  751. genBinaryABC(c, n, dest, opc)
  752. c.genNarrow(n, dest)
  753. proc genConv(c: PCtx; n, arg: PNode; dest: var TDest; opc=opcConv) =
  754. let t2 = n.typ.skipTypes({tyDistinct})
  755. let targ2 = arg.typ.skipTypes({tyDistinct})
  756. proc implicitConv(): bool =
  757. if sameType(t2, targ2): return true
  758. # xxx consider whether to use t2 and targ2 here
  759. if n.typ.kind == arg.typ.kind and arg.typ.kind == tyProc:
  760. # don't do anything for lambda lifting conversions:
  761. return true
  762. if implicitConv():
  763. gen(c, arg, dest)
  764. return
  765. let tmp = c.genx(arg)
  766. if dest < 0: dest = c.getTemp(n.typ)
  767. c.gABC(n, opc, dest, tmp)
  768. c.gABx(n, opc, 0, genType(c, n.typ.skipTypes({tyStatic})))
  769. c.gABx(n, opc, 0, genType(c, arg.typ.skipTypes({tyStatic})))
  770. c.freeTemp(tmp)
  771. proc genCard(c: PCtx; n: PNode; dest: var TDest) =
  772. let tmp = c.genx(n[1])
  773. if dest < 0: dest = c.getTemp(n.typ)
  774. c.genSetType(n[1], tmp)
  775. c.gABC(n, opcCard, dest, tmp)
  776. c.freeTemp(tmp)
  777. proc genCastIntFloat(c: PCtx; n: PNode; dest: var TDest) =
  778. const allowedIntegers = {tyInt..tyInt64, tyUInt..tyUInt64, tyChar}
  779. var signedIntegers = {tyInt..tyInt64}
  780. var unsignedIntegers = {tyUInt..tyUInt64, tyChar}
  781. let src = n[1].typ.skipTypes(abstractRange)#.kind
  782. let dst = n[0].typ.skipTypes(abstractRange)#.kind
  783. let srcSize = getSize(c.config, src)
  784. let dstSize = getSize(c.config, dst)
  785. if src.kind in allowedIntegers and dst.kind in allowedIntegers:
  786. let tmp = c.genx(n[1])
  787. if dest < 0: dest = c.getTemp(n[0].typ)
  788. c.gABC(n, opcAsgnInt, dest, tmp)
  789. if dstSize != sizeof(BiggestInt): # don't do anything on biggest int types
  790. if dst.kind in signedIntegers: # we need to do sign extensions
  791. if dstSize <= srcSize:
  792. # Sign extension can be omitted when the size increases.
  793. c.gABC(n, opcSignExtend, dest, TRegister(dstSize*8))
  794. elif dst.kind in unsignedIntegers:
  795. if src.kind in signedIntegers or dstSize < srcSize:
  796. # Cast from signed to unsigned always needs narrowing. Cast
  797. # from unsigned to unsigned only needs narrowing when target
  798. # is smaller than source.
  799. c.gABC(n, opcNarrowU, dest, TRegister(dstSize*8))
  800. c.freeTemp(tmp)
  801. elif srcSize == dstSize and src.kind in allowedIntegers and
  802. dst.kind in {tyFloat, tyFloat32, tyFloat64}:
  803. let tmp = c.genx(n[1])
  804. if dest < 0: dest = c.getTemp(n[0].typ)
  805. if dst.kind == tyFloat32:
  806. c.gABC(n, opcCastIntToFloat32, dest, tmp)
  807. else:
  808. c.gABC(n, opcCastIntToFloat64, dest, tmp)
  809. c.freeTemp(tmp)
  810. elif srcSize == dstSize and src.kind in {tyFloat, tyFloat32, tyFloat64} and
  811. dst.kind in allowedIntegers:
  812. let tmp = c.genx(n[1])
  813. if dest < 0: dest = c.getTemp(n[0].typ)
  814. if src.kind == tyFloat32:
  815. c.gABC(n, opcCastFloatToInt32, dest, tmp)
  816. if dst.kind in unsignedIntegers:
  817. # integers are sign extended by default.
  818. # since there is no opcCastFloatToUInt32, narrowing should do the trick.
  819. c.gABC(n, opcNarrowU, dest, TRegister(32))
  820. else:
  821. c.gABC(n, opcCastFloatToInt64, dest, tmp)
  822. # narrowing for 64 bits not needed (no extended sign bits available).
  823. c.freeTemp(tmp)
  824. elif src.kind in PtrLikeKinds + {tyRef} and dst.kind == tyInt:
  825. let tmp = c.genx(n[1])
  826. if dest < 0: dest = c.getTemp(n[0].typ)
  827. var imm: BiggestInt = if src.kind in PtrLikeKinds: 1 else: 2
  828. c.gABI(n, opcCastPtrToInt, dest, tmp, imm)
  829. c.freeTemp(tmp)
  830. elif src.kind in PtrLikeKinds + {tyInt} and dst.kind in PtrLikeKinds:
  831. let tmp = c.genx(n[1])
  832. if dest < 0: dest = c.getTemp(n[0].typ)
  833. c.gABx(n, opcSetType, dest, c.genType(dst))
  834. c.gABC(n, opcCastIntToPtr, dest, tmp)
  835. c.freeTemp(tmp)
  836. elif src.kind == tyNil and dst.kind in NilableTypes:
  837. # supports casting nil literals to NilableTypes in VM
  838. # see #16024
  839. if dest < 0: dest = c.getTemp(n[0].typ)
  840. genLit(c, n[1], dest)
  841. else:
  842. # todo: support cast from tyInt to tyRef
  843. globalError(c.config, n.info, "VM does not support 'cast' from " & $src.kind & " to " & $dst.kind)
  844. proc genVoidABC(c: PCtx, n: PNode, dest: TDest, opcode: TOpcode) =
  845. unused(c, n, dest)
  846. var
  847. tmp1 = c.genx(n[1])
  848. tmp2 = c.genx(n[2])
  849. tmp3 = c.genx(n[3])
  850. c.gABC(n, opcode, tmp1, tmp2, tmp3)
  851. c.freeTemp(tmp1)
  852. c.freeTemp(tmp2)
  853. c.freeTemp(tmp3)
  854. proc genBindSym(c: PCtx; n: PNode; dest: var TDest) =
  855. # nah, cannot use c.config.features because sempass context
  856. # can have local experimental switch
  857. # if dynamicBindSym notin c.config.features:
  858. if n.len == 2: # hmm, reliable?
  859. # bindSym with static input
  860. if n[1].kind in {nkClosedSymChoice, nkOpenSymChoice, nkSym}:
  861. let idx = c.genLiteral(n[1])
  862. if dest < 0: dest = c.getTemp(n.typ)
  863. c.gABx(n, opcNBindSym, dest, idx)
  864. else:
  865. localError(c.config, n.info, "invalid bindSym usage")
  866. else:
  867. # experimental bindSym
  868. if dest < 0: dest = c.getTemp(n.typ)
  869. let x = c.getTempRange(n.len, slotTempUnknown)
  870. # callee symbol
  871. var tmp0 = TDest(x)
  872. c.genLit(n[0], tmp0)
  873. # original parameters
  874. for i in 1..<n.len-2:
  875. var r = TRegister(x+i)
  876. c.gen(n[i], r)
  877. # info node
  878. var tmp1 = TDest(x+n.len-2)
  879. c.genLit(n[^2], tmp1)
  880. # payload idx
  881. var tmp2 = TDest(x+n.len-1)
  882. c.genLit(n[^1], tmp2)
  883. c.gABC(n, opcNDynBindSym, dest, x, n.len)
  884. c.freeTempRange(x, n.len)
  885. proc fitsRegister*(t: PType): bool =
  886. assert t != nil
  887. t.skipTypes(abstractInst + {tyStatic} - {tyTypeDesc}).kind in {
  888. tyRange, tyEnum, tyBool, tyInt..tyUInt64, tyChar}
  889. proc ldNullOpcode(t: PType): TOpcode =
  890. assert t != nil
  891. if fitsRegister(t): opcLdNullReg else: opcLdNull
  892. proc whichAsgnOpc(n: PNode; requiresCopy = true): TOpcode =
  893. case n.typ.skipTypes(abstractRange+{tyOwned}-{tyTypeDesc}).kind
  894. of tyBool, tyChar, tyEnum, tyOrdinal, tyInt..tyInt64, tyUInt..tyUInt64:
  895. opcAsgnInt
  896. of tyFloat..tyFloat128:
  897. opcAsgnFloat
  898. of tyRef, tyNil, tyVar, tyLent, tyPtr:
  899. opcAsgnRef
  900. else:
  901. (if requiresCopy: opcAsgnComplex else: opcFastAsgnComplex)
  902. proc genMagic(c: PCtx; n: PNode; dest: var TDest; m: TMagic) =
  903. case m
  904. of mAnd: c.genAndOr(n, opcFJmp, dest)
  905. of mOr: c.genAndOr(n, opcTJmp, dest)
  906. of mPred, mSubI:
  907. c.genAddSubInt(n, dest, opcSubInt)
  908. of mSucc, mAddI:
  909. c.genAddSubInt(n, dest, opcAddInt)
  910. of mInc, mDec:
  911. unused(c, n, dest)
  912. let isUnsigned = n[1].typ.skipTypes(abstractVarRange).kind in {tyUInt..tyUInt64}
  913. let opc = if not isUnsigned:
  914. if m == mInc: opcAddInt else: opcSubInt
  915. else:
  916. if m == mInc: opcAddu else: opcSubu
  917. let d = c.genx(n[1])
  918. if n[2].isInt8Lit and not isUnsigned:
  919. c.gABI(n, succ(opc), d, d, n[2].intVal)
  920. else:
  921. let tmp = c.genx(n[2])
  922. c.gABC(n, opc, d, d, tmp)
  923. c.freeTemp(tmp)
  924. c.genNarrow(n[1], d)
  925. c.genAsgnPatch(n[1], d)
  926. c.freeTemp(d)
  927. of mOrd, mChr, mArrToSeq, mUnown: c.gen(n[1], dest)
  928. of generatedMagics:
  929. genCall(c, n, dest)
  930. of mNew, mNewFinalize:
  931. unused(c, n, dest)
  932. c.genNew(n)
  933. of mNewSeq:
  934. unused(c, n, dest)
  935. c.genNewSeq(n)
  936. of mNewSeqOfCap: c.genNewSeqOfCap(n, dest)
  937. of mNewString:
  938. genUnaryABC(c, n, dest, opcNewStr)
  939. # XXX buggy
  940. of mNewStringOfCap:
  941. # we ignore the 'cap' argument and translate it as 'newString(0)'.
  942. # eval n[1] for possible side effects:
  943. c.freeTemp(c.genx(n[1]))
  944. var tmp = c.getTemp(n[1].typ)
  945. c.gABx(n, opcLdImmInt, tmp, 0)
  946. if dest < 0: dest = c.getTemp(n.typ)
  947. c.gABC(n, opcNewStr, dest, tmp)
  948. c.freeTemp(tmp)
  949. # XXX buggy
  950. of mLengthOpenArray, mLengthArray, mLengthSeq:
  951. genUnaryABI(c, n, dest, opcLenSeq)
  952. of mLengthStr:
  953. case n[1].typ.skipTypes(abstractVarRange).kind
  954. of tyString: genUnaryABI(c, n, dest, opcLenStr)
  955. of tyCstring: genUnaryABI(c, n, dest, opcLenCstring)
  956. else: doAssert false, $n[1].typ.kind
  957. of mSlice:
  958. var
  959. d = c.genx(n[1])
  960. left = c.genIndex(n[2], n[1].typ)
  961. right = c.genIndex(n[3], n[1].typ)
  962. if dest < 0: dest = c.getTemp(n.typ)
  963. c.gABC(n, opcNodeToReg, dest, d)
  964. c.gABC(n, opcSlice, dest, left, right)
  965. c.freeTemp(left)
  966. c.freeTemp(right)
  967. c.freeTemp(d)
  968. of mIncl, mExcl:
  969. unused(c, n, dest)
  970. var d = c.genx(n[1])
  971. var tmp = c.genx(n[2])
  972. c.genSetType(n[1], d)
  973. c.gABC(n, if m == mIncl: opcIncl else: opcExcl, d, tmp)
  974. c.freeTemp(d)
  975. c.freeTemp(tmp)
  976. of mCard: genCard(c, n, dest)
  977. of mMulI: genBinaryABCnarrow(c, n, dest, opcMulInt)
  978. of mDivI: genBinaryABCnarrow(c, n, dest, opcDivInt)
  979. of mModI: genBinaryABCnarrow(c, n, dest, opcModInt)
  980. of mAddF64: genBinaryABC(c, n, dest, opcAddFloat)
  981. of mSubF64: genBinaryABC(c, n, dest, opcSubFloat)
  982. of mMulF64: genBinaryABC(c, n, dest, opcMulFloat)
  983. of mDivF64: genBinaryABC(c, n, dest, opcDivFloat)
  984. of mShrI:
  985. # modified: genBinaryABC(c, n, dest, opcShrInt)
  986. # narrowU is applied to the left operandthe idea here is to narrow the left operand
  987. let tmp = c.genx(n[1])
  988. c.genNarrowU(n, tmp)
  989. let tmp2 = c.genx(n[2])
  990. if dest < 0: dest = c.getTemp(n.typ)
  991. c.gABC(n, opcShrInt, dest, tmp, tmp2)
  992. c.freeTemp(tmp)
  993. c.freeTemp(tmp2)
  994. of mShlI:
  995. genBinaryABC(c, n, dest, opcShlInt)
  996. # genNarrowU modified
  997. let t = skipTypes(n.typ, abstractVar-{tyTypeDesc})
  998. let size = getSize(c.config, t)
  999. if t.kind in {tyUInt8..tyUInt32} or (t.kind == tyUInt and size < 8):
  1000. c.gABC(n, opcNarrowU, dest, TRegister(size*8))
  1001. elif t.kind in {tyInt8..tyInt32} or (t.kind == tyInt and size < 8):
  1002. c.gABC(n, opcSignExtend, dest, TRegister(size*8))
  1003. of mAshrI: genBinaryABC(c, n, dest, opcAshrInt)
  1004. of mBitandI: genBinaryABC(c, n, dest, opcBitandInt)
  1005. of mBitorI: genBinaryABC(c, n, dest, opcBitorInt)
  1006. of mBitxorI: genBinaryABC(c, n, dest, opcBitxorInt)
  1007. of mAddU: genBinaryABCnarrowU(c, n, dest, opcAddu)
  1008. of mSubU: genBinaryABCnarrowU(c, n, dest, opcSubu)
  1009. of mMulU: genBinaryABCnarrowU(c, n, dest, opcMulu)
  1010. of mDivU: genBinaryABCnarrowU(c, n, dest, opcDivu)
  1011. of mModU: genBinaryABCnarrowU(c, n, dest, opcModu)
  1012. of mEqI, mEqB, mEqEnum, mEqCh:
  1013. genBinaryABC(c, n, dest, opcEqInt)
  1014. of mLeI, mLeEnum, mLeCh, mLeB:
  1015. genBinaryABC(c, n, dest, opcLeInt)
  1016. of mLtI, mLtEnum, mLtCh, mLtB:
  1017. genBinaryABC(c, n, dest, opcLtInt)
  1018. of mEqF64: genBinaryABC(c, n, dest, opcEqFloat)
  1019. of mLeF64: genBinaryABC(c, n, dest, opcLeFloat)
  1020. of mLtF64: genBinaryABC(c, n, dest, opcLtFloat)
  1021. of mLePtr, mLeU: genBinaryABC(c, n, dest, opcLeu)
  1022. of mLtPtr, mLtU: genBinaryABC(c, n, dest, opcLtu)
  1023. of mEqProc, mEqRef:
  1024. genBinaryABC(c, n, dest, opcEqRef)
  1025. of mXor: genBinaryABC(c, n, dest, opcXor)
  1026. of mNot: genUnaryABC(c, n, dest, opcNot)
  1027. of mUnaryMinusI, mUnaryMinusI64:
  1028. genUnaryABC(c, n, dest, opcUnaryMinusInt)
  1029. genNarrow(c, n, dest)
  1030. of mUnaryMinusF64: genUnaryABC(c, n, dest, opcUnaryMinusFloat)
  1031. of mUnaryPlusI, mUnaryPlusF64: gen(c, n[1], dest)
  1032. of mBitnotI:
  1033. genUnaryABC(c, n, dest, opcBitnotInt)
  1034. #genNarrowU modified, do not narrow signed types
  1035. let t = skipTypes(n.typ, abstractVar-{tyTypeDesc})
  1036. let size = getSize(c.config, t)
  1037. if t.kind in {tyUInt8..tyUInt32} or (t.kind == tyUInt and size < 8):
  1038. c.gABC(n, opcNarrowU, dest, TRegister(size*8))
  1039. of mCharToStr, mBoolToStr, mIntToStr, mInt64ToStr, mFloatToStr, mCStrToStr, mStrToStr, mEnumToStr:
  1040. genConv(c, n, n[1], dest)
  1041. of mEqStr, mEqCString: genBinaryABC(c, n, dest, opcEqStr)
  1042. of mLeStr: genBinaryABC(c, n, dest, opcLeStr)
  1043. of mLtStr: genBinaryABC(c, n, dest, opcLtStr)
  1044. of mEqSet: genBinarySet(c, n, dest, opcEqSet)
  1045. of mLeSet: genBinarySet(c, n, dest, opcLeSet)
  1046. of mLtSet: genBinarySet(c, n, dest, opcLtSet)
  1047. of mMulSet: genBinarySet(c, n, dest, opcMulSet)
  1048. of mPlusSet: genBinarySet(c, n, dest, opcPlusSet)
  1049. of mMinusSet: genBinarySet(c, n, dest, opcMinusSet)
  1050. of mConStrStr: genVarargsABC(c, n, dest, opcConcatStr)
  1051. of mInSet: genBinarySet(c, n, dest, opcContainsSet)
  1052. of mRepr: genUnaryABC(c, n, dest, opcRepr)
  1053. of mExit:
  1054. unused(c, n, dest)
  1055. var tmp = c.genx(n[1])
  1056. c.gABC(n, opcQuit, tmp)
  1057. c.freeTemp(tmp)
  1058. of mSetLengthStr, mSetLengthSeq:
  1059. unused(c, n, dest)
  1060. var d = c.genx(n[1])
  1061. var tmp = c.genx(n[2])
  1062. c.gABC(n, if m == mSetLengthStr: opcSetLenStr else: opcSetLenSeq, d, tmp)
  1063. c.genAsgnPatch(n[1], d)
  1064. c.freeTemp(tmp)
  1065. c.freeTemp(d)
  1066. of mSwap:
  1067. unused(c, n, dest)
  1068. c.gen(lowerSwap(c.graph, n, c.idgen, if c.prc == nil or c.prc.sym == nil: c.module else: c.prc.sym))
  1069. of mIsNil: genUnaryABC(c, n, dest, opcIsNil)
  1070. of mParseBiggestFloat:
  1071. if dest < 0: dest = c.getTemp(n.typ)
  1072. var d2: TRegister
  1073. # skip 'nkHiddenAddr':
  1074. let d2AsNode = n[2][0]
  1075. if needsAsgnPatch(d2AsNode):
  1076. d2 = c.getTemp(getSysType(c.graph, n.info, tyFloat))
  1077. else:
  1078. d2 = c.genx(d2AsNode)
  1079. var
  1080. tmp1 = c.genx(n[1])
  1081. c.gABC(n, opcParseFloat, dest, tmp1, d2)
  1082. c.freeTemp(tmp1)
  1083. c.genAsgnPatch(d2AsNode, d2)
  1084. c.freeTemp(d2)
  1085. of mReset:
  1086. unused(c, n, dest)
  1087. var d = c.genx(n[1])
  1088. # XXX use ldNullOpcode() here?
  1089. c.gABx(n, opcLdNull, d, c.genType(n[1].typ))
  1090. c.gABC(n, opcNodeToReg, d, d)
  1091. c.genAsgnPatch(n[1], d)
  1092. of mDefault, mZeroDefault:
  1093. if dest < 0: dest = c.getTemp(n.typ)
  1094. c.gABx(n, ldNullOpcode(n.typ), dest, c.genType(n.typ))
  1095. of mOf, mIs:
  1096. if dest < 0: dest = c.getTemp(n.typ)
  1097. var tmp = c.genx(n[1])
  1098. var idx = c.getTemp(getSysType(c.graph, n.info, tyInt))
  1099. var typ = n[2].typ
  1100. if m == mOf: typ = typ.skipTypes(abstractPtrs)
  1101. c.gABx(n, opcLdImmInt, idx, c.genType(typ))
  1102. c.gABC(n, if m == mOf: opcOf else: opcIs, dest, tmp, idx)
  1103. c.freeTemp(tmp)
  1104. c.freeTemp(idx)
  1105. of mHigh:
  1106. if dest < 0: dest = c.getTemp(n.typ)
  1107. let tmp = c.genx(n[1])
  1108. case n[1].typ.skipTypes(abstractVar-{tyTypeDesc}).kind:
  1109. of tyString: c.gABI(n, opcLenStr, dest, tmp, 1)
  1110. of tyCstring: c.gABI(n, opcLenCstring, dest, tmp, 1)
  1111. else: c.gABI(n, opcLenSeq, dest, tmp, 1)
  1112. c.freeTemp(tmp)
  1113. of mEcho:
  1114. unused(c, n, dest)
  1115. let n = n[1].skipConv
  1116. if n.kind == nkBracket:
  1117. # can happen for nim check, see bug #9609
  1118. let x = c.getTempRange(n.len, slotTempUnknown)
  1119. for i in 0..<n.len:
  1120. var r: TRegister = x+i
  1121. c.gen(n[i], r)
  1122. c.gABC(n, opcEcho, x, n.len)
  1123. c.freeTempRange(x, n.len)
  1124. of mAppendStrCh:
  1125. unused(c, n, dest)
  1126. genBinaryStmtVar(c, n, opcAddStrCh)
  1127. of mAppendStrStr:
  1128. unused(c, n, dest)
  1129. genBinaryStmtVar(c, n, opcAddStrStr)
  1130. of mAppendSeqElem:
  1131. unused(c, n, dest)
  1132. genBinaryStmtVar(c, n, opcAddSeqElem)
  1133. of mParseExprToAst:
  1134. genBinaryABC(c, n, dest, opcParseExprToAst)
  1135. of mParseStmtToAst:
  1136. genBinaryABC(c, n, dest, opcParseStmtToAst)
  1137. of mTypeTrait:
  1138. let tmp = c.genx(n[1])
  1139. if dest < 0: dest = c.getTemp(n.typ)
  1140. c.gABx(n, opcSetType, tmp, c.genType(n[1].typ))
  1141. c.gABC(n, opcTypeTrait, dest, tmp)
  1142. c.freeTemp(tmp)
  1143. of mSlurp: genUnaryABC(c, n, dest, opcSlurp)
  1144. of mStaticExec: genBinaryABCD(c, n, dest, opcGorge)
  1145. of mNLen: genUnaryABI(c, n, dest, opcLenSeq, nimNodeFlag)
  1146. of mGetImpl: genUnaryABC(c, n, dest, opcGetImpl)
  1147. of mGetImplTransf: genUnaryABC(c, n, dest, opcGetImplTransf)
  1148. of mSymOwner: genUnaryABC(c, n, dest, opcSymOwner)
  1149. of mSymIsInstantiationOf: genBinaryABC(c, n, dest, opcSymIsInstantiationOf)
  1150. of mNChild: genBinaryABC(c, n, dest, opcNChild)
  1151. of mNSetChild: genVoidABC(c, n, dest, opcNSetChild)
  1152. of mNDel: genVoidABC(c, n, dest, opcNDel)
  1153. of mNAdd: genBinaryABC(c, n, dest, opcNAdd)
  1154. of mNAddMultiple: genBinaryABC(c, n, dest, opcNAddMultiple)
  1155. of mNKind: genUnaryABC(c, n, dest, opcNKind)
  1156. of mNSymKind: genUnaryABC(c, n, dest, opcNSymKind)
  1157. of mNccValue: genUnaryABC(c, n, dest, opcNccValue)
  1158. of mNccInc: genBinaryABC(c, n, dest, opcNccInc)
  1159. of mNcsAdd: genBinaryABC(c, n, dest, opcNcsAdd)
  1160. of mNcsIncl: genBinaryABC(c, n, dest, opcNcsIncl)
  1161. of mNcsLen: genUnaryABC(c, n, dest, opcNcsLen)
  1162. of mNcsAt: genBinaryABC(c, n, dest, opcNcsAt)
  1163. of mNctPut: genVoidABC(c, n, dest, opcNctPut)
  1164. of mNctLen: genUnaryABC(c, n, dest, opcNctLen)
  1165. of mNctGet: genBinaryABC(c, n, dest, opcNctGet)
  1166. of mNctHasNext: genBinaryABC(c, n, dest, opcNctHasNext)
  1167. of mNctNext: genBinaryABC(c, n, dest, opcNctNext)
  1168. of mNIntVal: genUnaryABC(c, n, dest, opcNIntVal)
  1169. of mNFloatVal: genUnaryABC(c, n, dest, opcNFloatVal)
  1170. of mNSymbol: genUnaryABC(c, n, dest, opcNSymbol)
  1171. of mNIdent: genUnaryABC(c, n, dest, opcNIdent)
  1172. of mNGetType:
  1173. let tmp = c.genx(n[1])
  1174. if dest < 0: dest = c.getTemp(n.typ)
  1175. let rc = case n[0].sym.name.s:
  1176. of "getType": 0
  1177. of "typeKind": 1
  1178. of "getTypeInst": 2
  1179. else: 3 # "getTypeImpl"
  1180. c.gABC(n, opcNGetType, dest, tmp, rc)
  1181. c.freeTemp(tmp)
  1182. #genUnaryABC(c, n, dest, opcNGetType)
  1183. of mNSizeOf:
  1184. let imm = case n[0].sym.name.s:
  1185. of "getSize": 0
  1186. of "getAlign": 1
  1187. else: 2 # "getOffset"
  1188. c.genUnaryABI(n, dest, opcNGetSize, imm)
  1189. of mNStrVal: genUnaryABC(c, n, dest, opcNStrVal)
  1190. of mNSigHash: genUnaryABC(c, n , dest, opcNSigHash)
  1191. of mNSetIntVal:
  1192. unused(c, n, dest)
  1193. genBinaryStmt(c, n, opcNSetIntVal)
  1194. of mNSetFloatVal:
  1195. unused(c, n, dest)
  1196. genBinaryStmt(c, n, opcNSetFloatVal)
  1197. of mNSetSymbol:
  1198. unused(c, n, dest)
  1199. genBinaryStmt(c, n, opcNSetSymbol)
  1200. of mNSetIdent:
  1201. unused(c, n, dest)
  1202. genBinaryStmt(c, n, opcNSetIdent)
  1203. of mNSetType:
  1204. unused(c, n, dest)
  1205. genBinaryStmt(c, n, opcNSetType)
  1206. of mNSetStrVal:
  1207. unused(c, n, dest)
  1208. genBinaryStmt(c, n, opcNSetStrVal)
  1209. of mNNewNimNode: genBinaryABC(c, n, dest, opcNNewNimNode)
  1210. of mNCopyNimNode: genUnaryABC(c, n, dest, opcNCopyNimNode)
  1211. of mNCopyNimTree: genUnaryABC(c, n, dest, opcNCopyNimTree)
  1212. of mNBindSym: genBindSym(c, n, dest)
  1213. of mStrToIdent: genUnaryABC(c, n, dest, opcStrToIdent)
  1214. of mEqIdent: genBinaryABC(c, n, dest, opcEqIdent)
  1215. of mEqNimrodNode: genBinaryABC(c, n, dest, opcEqNimNode)
  1216. of mSameNodeType: genBinaryABC(c, n, dest, opcSameNodeType)
  1217. of mNLineInfo:
  1218. case n[0].sym.name.s
  1219. of "getFile": genUnaryABI(c, n, dest, opcNGetLineInfo, 0)
  1220. of "getLine": genUnaryABI(c, n, dest, opcNGetLineInfo, 1)
  1221. of "getColumn": genUnaryABI(c, n, dest, opcNGetLineInfo, 2)
  1222. of "copyLineInfo":
  1223. internalAssert c.config, n.len == 3
  1224. unused(c, n, dest)
  1225. genBinaryStmt(c, n, opcNSetLineInfo)
  1226. else: internalAssert c.config, false
  1227. of mNHint:
  1228. unused(c, n, dest)
  1229. genBinaryStmt(c, n, opcNHint)
  1230. of mNWarning:
  1231. unused(c, n, dest)
  1232. genBinaryStmt(c, n, opcNWarning)
  1233. of mNError:
  1234. if n.len <= 1:
  1235. # query error condition:
  1236. c.gABC(n, opcQueryErrorFlag, dest)
  1237. else:
  1238. # setter
  1239. unused(c, n, dest)
  1240. genBinaryStmt(c, n, opcNError)
  1241. of mNCallSite:
  1242. if dest < 0: dest = c.getTemp(n.typ)
  1243. c.gABC(n, opcCallSite, dest)
  1244. of mNGenSym: genBinaryABC(c, n, dest, opcGenSym)
  1245. of mMinI, mMaxI, mAbsI, mDotDot:
  1246. c.genCall(n, dest)
  1247. of mExpandToAst:
  1248. if n.len != 2:
  1249. globalError(c.config, n.info, "expandToAst requires 1 argument")
  1250. let arg = n[1]
  1251. if arg.kind in nkCallKinds:
  1252. #if arg[0].kind != nkSym or arg[0].sym.kind notin {skTemplate, skMacro}:
  1253. # "ExpandToAst: expanded symbol is no macro or template"
  1254. if dest < 0: dest = c.getTemp(n.typ)
  1255. c.genCall(arg, dest)
  1256. # do not call clearDest(n, dest) here as getAst has a meta-type as such
  1257. # produces a value
  1258. else:
  1259. globalError(c.config, n.info, "expandToAst requires a call expression")
  1260. of mSizeOf:
  1261. globalError(c.config, n.info, sizeOfLikeMsg("sizeof"))
  1262. of mAlignOf:
  1263. globalError(c.config, n.info, sizeOfLikeMsg("alignof"))
  1264. of mOffsetOf:
  1265. globalError(c.config, n.info, sizeOfLikeMsg("offsetof"))
  1266. of mRunnableExamples:
  1267. discard "just ignore any call to runnableExamples"
  1268. of mDestroy, mTrace: discard "ignore calls to the default destructor"
  1269. of mMove:
  1270. let arg = n[1]
  1271. let a = c.genx(arg)
  1272. if dest < 0: dest = c.getTemp(arg.typ)
  1273. gABC(c, arg, whichAsgnOpc(arg, requiresCopy=false), dest, a)
  1274. # XXX use ldNullOpcode() here?
  1275. # Don't zero out the arg for now #17199
  1276. # c.gABx(n, opcLdNull, a, c.genType(arg.typ))
  1277. # c.gABx(n, opcNodeToReg, a, a)
  1278. # c.genAsgnPatch(arg, a)
  1279. c.freeTemp(a)
  1280. of mNodeId:
  1281. c.genUnaryABC(n, dest, opcNodeId)
  1282. else:
  1283. # mGCref, mGCunref,
  1284. globalError(c.config, n.info, "cannot generate code for: " & $m)
  1285. proc unneededIndirection(n: PNode): bool =
  1286. n.typ.skipTypes(abstractInstOwned-{tyTypeDesc}).kind == tyRef
  1287. proc canElimAddr(n: PNode): PNode =
  1288. case n[0].kind
  1289. of nkObjUpConv, nkObjDownConv, nkChckRange, nkChckRangeF, nkChckRange64:
  1290. var m = n[0][0]
  1291. if m.kind in {nkDerefExpr, nkHiddenDeref}:
  1292. # addr ( nkConv ( deref ( x ) ) ) --> nkConv(x)
  1293. result = copyNode(n[0])
  1294. result.add m[0]
  1295. of nkHiddenStdConv, nkHiddenSubConv, nkConv:
  1296. var m = n[0][1]
  1297. if m.kind in {nkDerefExpr, nkHiddenDeref}:
  1298. # addr ( nkConv ( deref ( x ) ) ) --> nkConv(x)
  1299. result = copyNode(n[0])
  1300. result.add m[0]
  1301. else:
  1302. if n[0].kind in {nkDerefExpr, nkHiddenDeref}:
  1303. # addr ( deref ( x )) --> x
  1304. result = n[0][0]
  1305. proc genAddr(c: PCtx, n: PNode, dest: var TDest, flags: TGenFlags) =
  1306. if (let m = canElimAddr(n); m != nil):
  1307. gen(c, m, dest, flags)
  1308. return
  1309. let newflags = flags-{gfNode}+{gfNodeAddr}
  1310. if isGlobal(n[0]) or n[0].kind in {nkDotExpr, nkCheckedFieldExpr, nkBracketExpr}:
  1311. # checking for this pattern: addr(obj.field) / addr(array[i])
  1312. gen(c, n[0], dest, newflags)
  1313. else:
  1314. let tmp = c.genx(n[0], newflags)
  1315. if dest < 0: dest = c.getTemp(n.typ)
  1316. if c.prc.regInfo[tmp].kind >= slotTempUnknown:
  1317. gABC(c, n, opcAddrNode, dest, tmp)
  1318. # hack ahead; in order to fix bug #1781 we mark the temporary as
  1319. # permanent, so that it's not used for anything else:
  1320. c.prc.regInfo[tmp].kind = slotTempPerm
  1321. # XXX this is still a hack
  1322. #message(c.congig, n.info, warnUser, "suspicious opcode used")
  1323. else:
  1324. gABC(c, n, opcAddrReg, dest, tmp)
  1325. c.freeTemp(tmp)
  1326. proc genDeref(c: PCtx, n: PNode, dest: var TDest, flags: TGenFlags) =
  1327. if unneededIndirection(n[0]):
  1328. gen(c, n[0], dest, flags)
  1329. if {gfNodeAddr, gfNode} * flags == {} and fitsRegister(n.typ):
  1330. c.gABC(n, opcNodeToReg, dest, dest)
  1331. else:
  1332. let tmp = c.genx(n[0], flags)
  1333. if dest < 0: dest = c.getTemp(n.typ)
  1334. gABC(c, n, opcLdDeref, dest, tmp)
  1335. assert n.typ != nil
  1336. if {gfNodeAddr, gfNode} * flags == {} and fitsRegister(n.typ):
  1337. c.gABC(n, opcNodeToReg, dest, dest)
  1338. c.freeTemp(tmp)
  1339. proc genAsgn(c: PCtx; dest: TDest; ri: PNode; requiresCopy: bool) =
  1340. let tmp = c.genx(ri)
  1341. assert dest >= 0
  1342. gABC(c, ri, whichAsgnOpc(ri, requiresCopy), dest, tmp)
  1343. c.freeTemp(tmp)
  1344. proc setSlot(c: PCtx; v: PSym) =
  1345. # XXX generate type initialization here?
  1346. if v.position == 0:
  1347. v.position = getFreeRegister(c, if v.kind == skLet: slotFixedLet else: slotFixedVar, start = 1)
  1348. proc cannotEval(c: PCtx; n: PNode) {.noinline.} =
  1349. globalError(c.config, n.info, "cannot evaluate at compile time: " &
  1350. n.renderTree)
  1351. proc isOwnedBy(a, b: PSym): bool =
  1352. var a = a.owner
  1353. while a != nil and a.kind != skModule:
  1354. if a == b: return true
  1355. a = a.owner
  1356. proc getOwner(c: PCtx): PSym =
  1357. result = c.prc.sym
  1358. if result.isNil: result = c.module
  1359. proc importcCondVar*(s: PSym): bool {.inline.} =
  1360. # see also importcCond
  1361. if sfImportc in s.flags:
  1362. return s.kind in {skVar, skLet, skConst}
  1363. proc checkCanEval(c: PCtx; n: PNode) =
  1364. # we need to ensure that we don't evaluate 'x' here:
  1365. # proc foo() = var x ...
  1366. let s = n.sym
  1367. if {sfCompileTime, sfGlobal} <= s.flags: return
  1368. if compiletimeFFI in c.config.features and s.importcCondVar: return
  1369. if s.kind in {skVar, skTemp, skLet, skParam, skResult} and
  1370. not s.isOwnedBy(c.prc.sym) and s.owner != c.module and c.mode != emRepl:
  1371. # little hack ahead for bug #12612: assume gensym'ed variables
  1372. # are in the right scope:
  1373. if sfGenSym in s.flags and c.prc.sym == nil: discard
  1374. else: cannotEval(c, n)
  1375. elif s.kind in {skProc, skFunc, skConverter, skMethod,
  1376. skIterator} and sfForward in s.flags:
  1377. cannotEval(c, n)
  1378. template needsAdditionalCopy(n): untyped =
  1379. not c.isTemp(dest) and not fitsRegister(n.typ)
  1380. proc genAdditionalCopy(c: PCtx; n: PNode; opc: TOpcode;
  1381. dest, idx, value: TRegister) =
  1382. var cc = c.getTemp(n.typ)
  1383. c.gABC(n, whichAsgnOpc(n), cc, value)
  1384. c.gABC(n, opc, dest, idx, cc)
  1385. c.freeTemp(cc)
  1386. proc preventFalseAlias(c: PCtx; n: PNode; opc: TOpcode;
  1387. dest, idx, value: TRegister) =
  1388. # opcLdObj et al really means "load address". We sometimes have to create a
  1389. # copy in order to not introduce false aliasing:
  1390. # mylocal = a.b # needs a copy of the data!
  1391. assert n.typ != nil
  1392. if needsAdditionalCopy(n):
  1393. genAdditionalCopy(c, n, opc, dest, idx, value)
  1394. else:
  1395. c.gABC(n, opc, dest, idx, value)
  1396. proc genAsgn(c: PCtx; le, ri: PNode; requiresCopy: bool) =
  1397. case le.kind
  1398. of nkBracketExpr:
  1399. let
  1400. dest = c.genx(le[0], {gfNode})
  1401. idx = c.genIndex(le[1], le[0].typ)
  1402. tmp = c.genx(ri)
  1403. collTyp = le[0].typ.skipTypes(abstractVarRange-{tyTypeDesc})
  1404. case collTyp.kind
  1405. of tyString, tyCstring:
  1406. c.preventFalseAlias(le, opcWrStrIdx, dest, idx, tmp)
  1407. of tyTuple:
  1408. c.preventFalseAlias(le, opcWrObj, dest, int le[1].intVal, tmp)
  1409. else:
  1410. c.preventFalseAlias(le, opcWrArr, dest, idx, tmp)
  1411. c.freeTemp(tmp)
  1412. c.freeTemp(idx)
  1413. c.freeTemp(dest)
  1414. of nkCheckedFieldExpr:
  1415. var objR: TDest = -1
  1416. genCheckedObjAccessAux(c, le, objR, {gfNode})
  1417. let idx = genField(c, le[0][1])
  1418. let tmp = c.genx(ri)
  1419. c.preventFalseAlias(le[0], opcWrObj, objR, idx, tmp)
  1420. c.freeTemp(tmp)
  1421. # c.freeTemp(idx) # BUGFIX, see nkDotExpr
  1422. c.freeTemp(objR)
  1423. of nkDotExpr:
  1424. let dest = c.genx(le[0], {gfNode})
  1425. let idx = genField(c, le[1])
  1426. let tmp = c.genx(ri)
  1427. c.preventFalseAlias(le, opcWrObj, dest, idx, tmp)
  1428. # c.freeTemp(idx) # BUGFIX: idx is an immediate (field position), not a register
  1429. c.freeTemp(tmp)
  1430. c.freeTemp(dest)
  1431. of nkDerefExpr, nkHiddenDeref:
  1432. let dest = c.genx(le[0], {gfNode})
  1433. let tmp = c.genx(ri)
  1434. c.preventFalseAlias(le, opcWrDeref, dest, 0, tmp)
  1435. c.freeTemp(dest)
  1436. c.freeTemp(tmp)
  1437. of nkSym:
  1438. let s = le.sym
  1439. checkCanEval(c, le)
  1440. if s.isGlobal:
  1441. withTemp(tmp, le.typ):
  1442. c.gen(le, tmp, {gfNodeAddr})
  1443. let val = c.genx(ri)
  1444. c.preventFalseAlias(le, opcWrDeref, tmp, 0, val)
  1445. c.freeTemp(val)
  1446. else:
  1447. if s.kind == skForVar: c.setSlot s
  1448. internalAssert c.config, s.position > 0 or (s.position == 0 and
  1449. s.kind in {skParam, skResult})
  1450. var dest: TRegister = s.position + ord(s.kind == skParam)
  1451. assert le.typ != nil
  1452. if needsAdditionalCopy(le) and s.kind in {skResult, skVar, skParam}:
  1453. var cc = c.getTemp(le.typ)
  1454. gen(c, ri, cc)
  1455. c.gABC(le, whichAsgnOpc(le), dest, cc)
  1456. c.freeTemp(cc)
  1457. else:
  1458. gen(c, ri, dest)
  1459. else:
  1460. let dest = c.genx(le, {gfNodeAddr})
  1461. genAsgn(c, dest, ri, requiresCopy)
  1462. c.freeTemp(dest)
  1463. proc genTypeLit(c: PCtx; t: PType; dest: var TDest) =
  1464. var n = newNode(nkType)
  1465. n.typ = t
  1466. genLit(c, n, dest)
  1467. proc isEmptyBody(n: PNode): bool =
  1468. case n.kind
  1469. of nkStmtList:
  1470. for i in 0..<n.len:
  1471. if not isEmptyBody(n[i]): return false
  1472. result = true
  1473. else:
  1474. result = n.kind in {nkCommentStmt, nkEmpty}
  1475. proc importcCond*(c: PCtx; s: PSym): bool {.inline.} =
  1476. ## return true to importc `s`, false to execute its body instead (refs #8405)
  1477. if sfImportc in s.flags:
  1478. if s.kind in routineKinds:
  1479. return isEmptyBody(getBody(c.graph, s))
  1480. proc importcSym(c: PCtx; info: TLineInfo; s: PSym) =
  1481. when hasFFI:
  1482. if compiletimeFFI in c.config.features:
  1483. c.globals.add(importcSymbol(c.config, s))
  1484. s.position = c.globals.len
  1485. else:
  1486. localError(c.config, info,
  1487. "VM is not allowed to 'importc' without --experimental:compiletimeFFI")
  1488. else:
  1489. localError(c.config, info,
  1490. "cannot 'importc' variable at compile time; " & s.name.s)
  1491. proc getNullValue*(typ: PType, info: TLineInfo; conf: ConfigRef): PNode
  1492. proc genGlobalInit(c: PCtx; n: PNode; s: PSym) =
  1493. c.globals.add(getNullValue(s.typ, n.info, c.config))
  1494. s.position = c.globals.len
  1495. # This is rather hard to support, due to the laziness of the VM code
  1496. # generator. See tests/compile/tmacro2 for why this is necessary:
  1497. # var decls{.compileTime.}: seq[NimNode] = @[]
  1498. let dest = c.getTemp(s.typ)
  1499. c.gABx(n, opcLdGlobal, dest, s.position)
  1500. if s.astdef != nil:
  1501. let tmp = c.genx(s.astdef)
  1502. c.genAdditionalCopy(n, opcWrDeref, dest, 0, tmp)
  1503. c.freeTemp(dest)
  1504. c.freeTemp(tmp)
  1505. proc genRdVar(c: PCtx; n: PNode; dest: var TDest; flags: TGenFlags) =
  1506. # gfNodeAddr and gfNode are mutually exclusive
  1507. assert card(flags * {gfNodeAddr, gfNode}) < 2
  1508. let s = n.sym
  1509. if s.isGlobal:
  1510. let isImportcVar = importcCondVar(s)
  1511. if sfCompileTime in s.flags or c.mode == emRepl or isImportcVar:
  1512. discard
  1513. elif s.position == 0:
  1514. cannotEval(c, n)
  1515. if s.position == 0:
  1516. if importcCond(c, s) or isImportcVar: c.importcSym(n.info, s)
  1517. else: genGlobalInit(c, n, s)
  1518. if dest < 0: dest = c.getTemp(n.typ)
  1519. assert s.typ != nil
  1520. if gfNodeAddr in flags:
  1521. if isImportcVar:
  1522. c.gABx(n, opcLdGlobalAddrDerefFFI, dest, s.position)
  1523. else:
  1524. c.gABx(n, opcLdGlobalAddr, dest, s.position)
  1525. elif isImportcVar:
  1526. c.gABx(n, opcLdGlobalDerefFFI, dest, s.position)
  1527. elif fitsRegister(s.typ) and gfNode notin flags:
  1528. var cc = c.getTemp(n.typ)
  1529. c.gABx(n, opcLdGlobal, cc, s.position)
  1530. c.gABC(n, opcNodeToReg, dest, cc)
  1531. c.freeTemp(cc)
  1532. else:
  1533. c.gABx(n, opcLdGlobal, dest, s.position)
  1534. else:
  1535. if s.kind == skForVar and c.mode == emRepl: c.setSlot(s)
  1536. if s.position > 0 or (s.position == 0 and
  1537. s.kind in {skParam, skResult}):
  1538. if dest < 0:
  1539. dest = s.position + ord(s.kind == skParam)
  1540. internalAssert(c.config, c.prc.regInfo[dest].kind < slotSomeTemp)
  1541. else:
  1542. # we need to generate an assignment:
  1543. let requiresCopy = c.prc.regInfo[dest].kind >= slotSomeTemp and
  1544. gfIsParam notin flags
  1545. genAsgn(c, dest, n, requiresCopy)
  1546. else:
  1547. # see tests/t99bott for an example that triggers it:
  1548. cannotEval(c, n)
  1549. template needsRegLoad(): untyped =
  1550. {gfNode, gfNodeAddr} * flags == {} and
  1551. fitsRegister(n.typ.skipTypes({tyVar, tyLent, tyStatic}))
  1552. proc genArrAccessOpcode(c: PCtx; n: PNode; dest: var TDest; opc: TOpcode;
  1553. flags: TGenFlags) =
  1554. let a = c.genx(n[0], flags)
  1555. let b = c.genIndex(n[1], n[0].typ)
  1556. if dest < 0: dest = c.getTemp(n.typ)
  1557. if opc in {opcLdArrAddr, opcLdStrIdxAddr} and gfNodeAddr in flags:
  1558. c.gABC(n, opc, dest, a, b)
  1559. elif needsRegLoad():
  1560. var cc = c.getTemp(n.typ)
  1561. c.gABC(n, opc, cc, a, b)
  1562. c.gABC(n, opcNodeToReg, dest, cc)
  1563. c.freeTemp(cc)
  1564. else:
  1565. #message(c.config, n.info, warnUser, "argh")
  1566. #echo "FLAGS ", flags, " ", fitsRegister(n.typ), " ", typeToString(n.typ)
  1567. c.gABC(n, opc, dest, a, b)
  1568. c.freeTemp(a)
  1569. c.freeTemp(b)
  1570. proc genObjAccessAux(c: PCtx; n: PNode; a, b: int, dest: var TDest; flags: TGenFlags) =
  1571. if dest < 0: dest = c.getTemp(n.typ)
  1572. if {gfNodeAddr} * flags != {}:
  1573. c.gABC(n, opcLdObjAddr, dest, a, b)
  1574. elif needsRegLoad():
  1575. var cc = c.getTemp(n.typ)
  1576. c.gABC(n, opcLdObj, cc, a, b)
  1577. c.gABC(n, opcNodeToReg, dest, cc)
  1578. c.freeTemp(cc)
  1579. else:
  1580. c.gABC(n, opcLdObj, dest, a, b)
  1581. c.freeTemp(a)
  1582. proc genObjAccess(c: PCtx; n: PNode; dest: var TDest; flags: TGenFlags) =
  1583. genObjAccessAux(c, n, c.genx(n[0], flags), genField(c, n[1]), dest, flags)
  1584. proc genCheckedObjAccessAux(c: PCtx; n: PNode; dest: var TDest; flags: TGenFlags) =
  1585. internalAssert c.config, n.kind == nkCheckedFieldExpr
  1586. # nkDotExpr to access the requested field
  1587. let accessExpr = n[0]
  1588. # nkCall to check if the discriminant is valid
  1589. var checkExpr = n[1]
  1590. let negCheck = checkExpr[0].sym.magic == mNot
  1591. if negCheck:
  1592. checkExpr = checkExpr[^1]
  1593. # Discriminant symbol
  1594. let disc = checkExpr[2]
  1595. internalAssert c.config, disc.sym.kind == skField
  1596. # Load the object in `dest`
  1597. c.gen(accessExpr[0], dest, flags)
  1598. # Load the discriminant
  1599. var discVal = c.getTemp(disc.typ)
  1600. c.gABC(n, opcLdObj, discVal, dest, genField(c, disc))
  1601. # Check if its value is contained in the supplied set
  1602. let setLit = c.genx(checkExpr[1])
  1603. var rs = c.getTemp(getSysType(c.graph, n.info, tyBool))
  1604. c.gABC(n, opcContainsSet, rs, setLit, discVal)
  1605. c.freeTemp(discVal)
  1606. c.freeTemp(setLit)
  1607. # If the check fails let the user know
  1608. let lab1 = c.xjmp(n, if negCheck: opcFJmp else: opcTJmp, rs)
  1609. c.freeTemp(rs)
  1610. let strType = getSysType(c.graph, n.info, tyString)
  1611. var msgReg: TDest = c.getTemp(strType)
  1612. let fieldName = $accessExpr[1]
  1613. let msg = genFieldDefect(c.config, fieldName, disc.sym)
  1614. let strLit = newStrNode(msg, accessExpr[1].info)
  1615. strLit.typ = strType
  1616. c.genLit(strLit, msgReg)
  1617. c.gABC(n, opcInvalidField, msgReg, discVal)
  1618. c.freeTemp(msgReg)
  1619. c.patch(lab1)
  1620. proc genCheckedObjAccess(c: PCtx; n: PNode; dest: var TDest; flags: TGenFlags) =
  1621. var objR: TDest = -1
  1622. genCheckedObjAccessAux(c, n, objR, flags)
  1623. let accessExpr = n[0]
  1624. # Field symbol
  1625. var field = accessExpr[1]
  1626. internalAssert c.config, field.sym.kind == skField
  1627. # Load the content now
  1628. if dest < 0: dest = c.getTemp(n.typ)
  1629. let fieldPos = genField(c, field)
  1630. if {gfNodeAddr} * flags != {}:
  1631. c.gABC(n, opcLdObjAddr, dest, objR, fieldPos)
  1632. elif needsRegLoad():
  1633. var cc = c.getTemp(accessExpr.typ)
  1634. c.gABC(n, opcLdObj, cc, objR, fieldPos)
  1635. c.gABC(n, opcNodeToReg, dest, cc)
  1636. c.freeTemp(cc)
  1637. else:
  1638. c.gABC(n, opcLdObj, dest, objR, fieldPos)
  1639. c.freeTemp(objR)
  1640. proc genArrAccess(c: PCtx; n: PNode; dest: var TDest; flags: TGenFlags) =
  1641. let arrayType = n[0].typ.skipTypes(abstractVarRange-{tyTypeDesc}).kind
  1642. case arrayType
  1643. of tyString, tyCstring:
  1644. let opc = if gfNodeAddr in flags: opcLdStrIdxAddr else: opcLdStrIdx
  1645. genArrAccessOpcode(c, n, dest, opc, flags)
  1646. of tyTuple:
  1647. c.genObjAccessAux(n, c.genx(n[0], flags), int n[1].intVal, dest, flags)
  1648. of tyTypeDesc:
  1649. c.genTypeLit(n.typ, dest)
  1650. else:
  1651. let opc = if gfNodeAddr in flags: opcLdArrAddr else: opcLdArr
  1652. genArrAccessOpcode(c, n, dest, opc, flags)
  1653. proc getNullValueAux(t: PType; obj: PNode, result: PNode; conf: ConfigRef; currPosition: var int) =
  1654. if t != nil and t.len > 0 and t[0] != nil:
  1655. let b = skipTypes(t[0], skipPtrs)
  1656. getNullValueAux(b, b.n, result, conf, currPosition)
  1657. case obj.kind
  1658. of nkRecList:
  1659. for i in 0..<obj.len: getNullValueAux(nil, obj[i], result, conf, currPosition)
  1660. of nkRecCase:
  1661. getNullValueAux(nil, obj[0], result, conf, currPosition)
  1662. for i in 1..<obj.len:
  1663. getNullValueAux(nil, lastSon(obj[i]), result, conf, currPosition)
  1664. of nkSym:
  1665. let field = newNodeI(nkExprColonExpr, result.info)
  1666. field.add(obj)
  1667. let value = getNullValue(obj.sym.typ, result.info, conf)
  1668. value.flags.incl nfUseDefaultField
  1669. field.add(value)
  1670. result.add field
  1671. doAssert obj.sym.position == currPosition
  1672. inc currPosition
  1673. else: globalError(conf, result.info, "cannot create null element for: " & $obj)
  1674. proc getNullValue(typ: PType, info: TLineInfo; conf: ConfigRef): PNode =
  1675. var t = skipTypes(typ, abstractRange+{tyStatic, tyOwned}-{tyTypeDesc})
  1676. case t.kind
  1677. of tyBool, tyEnum, tyChar, tyInt..tyInt64:
  1678. result = newNodeIT(nkIntLit, info, t)
  1679. of tyUInt..tyUInt64:
  1680. result = newNodeIT(nkUIntLit, info, t)
  1681. of tyFloat..tyFloat128:
  1682. result = newNodeIT(nkFloatLit, info, t)
  1683. of tyCstring, tyString:
  1684. result = newNodeIT(nkStrLit, info, t)
  1685. result.strVal = ""
  1686. of tyVar, tyLent, tyPointer, tyPtr, tyUntyped,
  1687. tyTyped, tyTypeDesc, tyRef, tyNil:
  1688. result = newNodeIT(nkNilLit, info, t)
  1689. of tyProc:
  1690. if t.callConv != ccClosure:
  1691. result = newNodeIT(nkNilLit, info, t)
  1692. else:
  1693. result = newNodeIT(nkTupleConstr, info, t)
  1694. result.add(newNodeIT(nkNilLit, info, t))
  1695. result.add(newNodeIT(nkNilLit, info, t))
  1696. of tyObject:
  1697. result = newNodeIT(nkObjConstr, info, t)
  1698. result.add(newNodeIT(nkEmpty, info, t))
  1699. # initialize inherited fields, and all in the correct order:
  1700. var currPosition = 0
  1701. getNullValueAux(t, t.n, result, conf, currPosition)
  1702. of tyArray:
  1703. result = newNodeIT(nkBracket, info, t)
  1704. for i in 0..<toInt(lengthOrd(conf, t)):
  1705. result.add getNullValue(elemType(t), info, conf)
  1706. of tyTuple:
  1707. result = newNodeIT(nkTupleConstr, info, t)
  1708. for i in 0..<t.len:
  1709. result.add getNullValue(t[i], info, conf)
  1710. of tySet:
  1711. result = newNodeIT(nkCurly, info, t)
  1712. of tySequence, tyOpenArray:
  1713. result = newNodeIT(nkBracket, info, t)
  1714. else:
  1715. globalError(conf, info, "cannot create null element for: " & $t.kind)
  1716. result = newNodeI(nkEmpty, info)
  1717. proc genVarSection(c: PCtx; n: PNode) =
  1718. for a in n:
  1719. if a.kind == nkCommentStmt: continue
  1720. #assert(a[0].kind == nkSym) can happen for transformed vars
  1721. if a.kind == nkVarTuple:
  1722. for i in 0..<a.len-2:
  1723. if a[i].kind == nkSym:
  1724. if not a[i].sym.isGlobal: setSlot(c, a[i].sym)
  1725. checkCanEval(c, a[i])
  1726. c.gen(lowerTupleUnpacking(c.graph, a, c.idgen, c.getOwner))
  1727. elif a[0].kind == nkSym:
  1728. let s = a[0].sym
  1729. checkCanEval(c, a[0])
  1730. if s.isGlobal:
  1731. if s.position == 0:
  1732. if importcCond(c, s): c.importcSym(a.info, s)
  1733. else:
  1734. let sa = getNullValue(s.typ, a.info, c.config)
  1735. #if s.ast.isNil: getNullValue(s.typ, a.info)
  1736. #else: s.ast
  1737. assert sa.kind != nkCall
  1738. c.globals.add(sa)
  1739. s.position = c.globals.len
  1740. if a[2].kind != nkEmpty:
  1741. let tmp = c.genx(a[0], {gfNodeAddr})
  1742. let val = c.genx(a[2])
  1743. c.genAdditionalCopy(a[2], opcWrDeref, tmp, 0, val)
  1744. c.freeTemp(val)
  1745. c.freeTemp(tmp)
  1746. else:
  1747. setSlot(c, s)
  1748. if a[2].kind == nkEmpty:
  1749. c.gABx(a, ldNullOpcode(s.typ), s.position, c.genType(s.typ))
  1750. else:
  1751. assert s.typ != nil
  1752. if not fitsRegister(s.typ):
  1753. c.gABx(a, ldNullOpcode(s.typ), s.position, c.genType(s.typ))
  1754. let le = a[0]
  1755. assert le.typ != nil
  1756. if not fitsRegister(le.typ) and s.kind in {skResult, skVar, skParam}:
  1757. var cc = c.getTemp(le.typ)
  1758. gen(c, a[2], cc)
  1759. c.gABC(le, whichAsgnOpc(le), s.position.TRegister, cc)
  1760. c.freeTemp(cc)
  1761. else:
  1762. gen(c, a[2], s.position.TRegister)
  1763. else:
  1764. # assign to a[0]; happens for closures
  1765. if a[2].kind == nkEmpty:
  1766. let tmp = genx(c, a[0])
  1767. c.gABx(a, ldNullOpcode(a[0].typ), tmp, c.genType(a[0].typ))
  1768. c.freeTemp(tmp)
  1769. else:
  1770. genAsgn(c, a[0], a[2], true)
  1771. proc genArrayConstr(c: PCtx, n: PNode, dest: var TDest) =
  1772. if dest < 0: dest = c.getTemp(n.typ)
  1773. c.gABx(n, opcLdNull, dest, c.genType(n.typ))
  1774. let intType = getSysType(c.graph, n.info, tyInt)
  1775. let seqType = n.typ.skipTypes(abstractVar-{tyTypeDesc})
  1776. if seqType.kind == tySequence:
  1777. var tmp = c.getTemp(intType)
  1778. c.gABx(n, opcLdImmInt, tmp, n.len)
  1779. c.gABx(n, opcNewSeq, dest, c.genType(seqType))
  1780. c.gABx(n, opcNewSeq, tmp, 0)
  1781. c.freeTemp(tmp)
  1782. if n.len > 0:
  1783. var tmp = getTemp(c, intType)
  1784. c.gABx(n, opcLdNullReg, tmp, c.genType(intType))
  1785. for x in n:
  1786. let a = c.genx(x)
  1787. c.preventFalseAlias(n, opcWrArr, dest, tmp, a)
  1788. c.gABI(n, opcAddImmInt, tmp, tmp, 1)
  1789. c.freeTemp(a)
  1790. c.freeTemp(tmp)
  1791. proc genSetConstr(c: PCtx, n: PNode, dest: var TDest) =
  1792. if dest < 0: dest = c.getTemp(n.typ)
  1793. c.gABx(n, opcLdNull, dest, c.genType(n.typ))
  1794. for x in n:
  1795. if x.kind == nkRange:
  1796. let a = c.genx(x[0])
  1797. let b = c.genx(x[1])
  1798. c.gABC(n, opcInclRange, dest, a, b)
  1799. c.freeTemp(b)
  1800. c.freeTemp(a)
  1801. else:
  1802. let a = c.genx(x)
  1803. c.gABC(n, opcIncl, dest, a)
  1804. c.freeTemp(a)
  1805. proc genObjConstr(c: PCtx, n: PNode, dest: var TDest) =
  1806. if dest < 0: dest = c.getTemp(n.typ)
  1807. let t = n.typ.skipTypes(abstractRange+{tyOwned}-{tyTypeDesc})
  1808. if t.kind == tyRef:
  1809. c.gABx(n, opcNew, dest, c.genType(t[0]))
  1810. else:
  1811. c.gABx(n, opcLdNull, dest, c.genType(n.typ))
  1812. for i in 1..<n.len:
  1813. let it = n[i]
  1814. if it.kind == nkExprColonExpr and it[0].kind == nkSym:
  1815. let idx = genField(c, it[0])
  1816. let tmp = c.genx(it[1])
  1817. c.preventFalseAlias(it[1], opcWrObj,
  1818. dest, idx, tmp)
  1819. c.freeTemp(tmp)
  1820. else:
  1821. globalError(c.config, n.info, "invalid object constructor")
  1822. proc genTupleConstr(c: PCtx, n: PNode, dest: var TDest) =
  1823. if dest < 0: dest = c.getTemp(n.typ)
  1824. if n.typ.kind != tyTypeDesc:
  1825. c.gABx(n, opcLdNull, dest, c.genType(n.typ))
  1826. # XXX x = (x.old, 22) produces wrong code ... stupid self assignments
  1827. for i in 0..<n.len:
  1828. let it = n[i]
  1829. if it.kind == nkExprColonExpr:
  1830. let idx = genField(c, it[0])
  1831. let tmp = c.genx(it[1])
  1832. c.preventFalseAlias(it[1], opcWrObj,
  1833. dest, idx, tmp)
  1834. c.freeTemp(tmp)
  1835. else:
  1836. let tmp = c.genx(it)
  1837. c.preventFalseAlias(it, opcWrObj, dest, i.TRegister, tmp)
  1838. c.freeTemp(tmp)
  1839. proc genProc*(c: PCtx; s: PSym): int
  1840. proc matches(s: PSym; x: string): bool =
  1841. let y = x.split('.')
  1842. var s = s
  1843. for i in 1..y.len:
  1844. if s == nil or (y[^i].cmpIgnoreStyle(s.name.s) != 0 and y[^i] != "*"):
  1845. return false
  1846. s = if sfFromGeneric in s.flags: s.owner.owner else: s.owner
  1847. while s != nil and s.kind == skPackage and s.owner != nil: s = s.owner
  1848. result = true
  1849. proc procIsCallback(c: PCtx; s: PSym): bool =
  1850. if s.offset < -1: return true
  1851. var i = -2
  1852. for key, value in items(c.callbacks):
  1853. if s.matches(key):
  1854. doAssert s.offset == -1
  1855. s.offset = i
  1856. return true
  1857. dec i
  1858. proc gen(c: PCtx; n: PNode; dest: var TDest; flags: TGenFlags = {}) =
  1859. when defined(nimCompilerStacktraceHints):
  1860. setFrameMsg c.config$n.info & " " & $n.kind & " " & $flags
  1861. case n.kind
  1862. of nkSym:
  1863. let s = n.sym
  1864. checkCanEval(c, n)
  1865. case s.kind
  1866. of skVar, skForVar, skTemp, skLet, skParam, skResult:
  1867. genRdVar(c, n, dest, flags)
  1868. of skProc, skFunc, skConverter, skMacro, skTemplate, skMethod, skIterator:
  1869. # 'skTemplate' is only allowed for 'getAst' support:
  1870. if s.kind == skIterator and s.typ.callConv == TCallingConvention.ccClosure:
  1871. globalError(c.config, n.info, "Closure iterators are not supported by VM!")
  1872. if procIsCallback(c, s): discard
  1873. elif importcCond(c, s): c.importcSym(n.info, s)
  1874. genLit(c, n, dest)
  1875. of skConst:
  1876. let constVal = if s.astdef != nil: s.astdef else: s.typ.n
  1877. gen(c, constVal, dest)
  1878. of skEnumField:
  1879. # we never reach this case - as of the time of this comment,
  1880. # skEnumField is folded to an int in semfold.nim, but this code
  1881. # remains for robustness
  1882. if dest < 0: dest = c.getTemp(n.typ)
  1883. if s.position >= low(int16) and s.position <= high(int16):
  1884. c.gABx(n, opcLdImmInt, dest, s.position)
  1885. else:
  1886. var lit = genLiteral(c, newIntNode(nkIntLit, s.position))
  1887. c.gABx(n, opcLdConst, dest, lit)
  1888. of skType:
  1889. genTypeLit(c, s.typ, dest)
  1890. of skGenericParam:
  1891. if c.prc.sym != nil and c.prc.sym.kind == skMacro:
  1892. genRdVar(c, n, dest, flags)
  1893. else:
  1894. globalError(c.config, n.info, "cannot generate code for: " & s.name.s)
  1895. else:
  1896. globalError(c.config, n.info, "cannot generate code for: " & s.name.s)
  1897. of nkCallKinds:
  1898. if n[0].kind == nkSym:
  1899. let s = n[0].sym
  1900. if s.magic != mNone:
  1901. genMagic(c, n, dest, s.magic)
  1902. elif s.kind == skMethod:
  1903. localError(c.config, n.info, "cannot call method " & s.name.s &
  1904. " at compile time")
  1905. else:
  1906. genCall(c, n, dest)
  1907. clearDest(c, n, dest)
  1908. else:
  1909. genCall(c, n, dest)
  1910. clearDest(c, n, dest)
  1911. of nkCharLit..nkInt64Lit:
  1912. if isInt16Lit(n):
  1913. if dest < 0: dest = c.getTemp(n.typ)
  1914. c.gABx(n, opcLdImmInt, dest, n.intVal.int)
  1915. else:
  1916. genLit(c, n, dest)
  1917. of nkUIntLit..pred(nkNilLit): genLit(c, n, dest)
  1918. of nkNilLit:
  1919. if not n.typ.isEmptyType: genLit(c, getNullValue(n.typ, n.info, c.config), dest)
  1920. else: unused(c, n, dest)
  1921. of nkAsgn, nkFastAsgn, nkSinkAsgn:
  1922. unused(c, n, dest)
  1923. genAsgn(c, n[0], n[1], n.kind == nkAsgn)
  1924. of nkDotExpr: genObjAccess(c, n, dest, flags)
  1925. of nkCheckedFieldExpr: genCheckedObjAccess(c, n, dest, flags)
  1926. of nkBracketExpr: genArrAccess(c, n, dest, flags)
  1927. of nkDerefExpr, nkHiddenDeref: genDeref(c, n, dest, flags)
  1928. of nkAddr, nkHiddenAddr: genAddr(c, n, dest, flags)
  1929. of nkIfStmt, nkIfExpr: genIf(c, n, dest)
  1930. of nkWhenStmt:
  1931. # This is "when nimvm" node. Chose the first branch.
  1932. gen(c, n[0][1], dest)
  1933. of nkCaseStmt: genCase(c, n, dest)
  1934. of nkWhileStmt:
  1935. unused(c, n, dest)
  1936. genWhile(c, n)
  1937. of nkBlockExpr, nkBlockStmt: genBlock(c, n, dest)
  1938. of nkReturnStmt:
  1939. genReturn(c, n)
  1940. of nkRaiseStmt:
  1941. genRaise(c, n)
  1942. of nkBreakStmt:
  1943. genBreak(c, n)
  1944. of nkTryStmt, nkHiddenTryStmt: genTry(c, n, dest)
  1945. of nkStmtList:
  1946. #unused(c, n, dest)
  1947. # XXX Fix this bug properly, lexim triggers it
  1948. for x in n: gen(c, x)
  1949. of nkStmtListExpr:
  1950. for i in 0..<n.len-1: gen(c, n[i])
  1951. gen(c, n[^1], dest, flags)
  1952. of nkPragmaBlock:
  1953. gen(c, n.lastSon, dest, flags)
  1954. of nkDiscardStmt:
  1955. unused(c, n, dest)
  1956. gen(c, n[0])
  1957. of nkHiddenStdConv, nkHiddenSubConv, nkConv:
  1958. genConv(c, n, n[1], dest)
  1959. of nkObjDownConv:
  1960. genConv(c, n, n[0], dest)
  1961. of nkObjUpConv:
  1962. genConv(c, n, n[0], dest)
  1963. of nkVarSection, nkLetSection:
  1964. unused(c, n, dest)
  1965. genVarSection(c, n)
  1966. of declarativeDefs, nkMacroDef:
  1967. unused(c, n, dest)
  1968. of nkLambdaKinds:
  1969. #let s = n[namePos].sym
  1970. #discard genProc(c, s)
  1971. genLit(c, newSymNode(n[namePos].sym), dest)
  1972. of nkChckRangeF, nkChckRange64, nkChckRange:
  1973. let
  1974. tmp0 = c.genx(n[0])
  1975. tmp1 = c.genx(n[1])
  1976. tmp2 = c.genx(n[2])
  1977. c.gABC(n, opcRangeChck, tmp0, tmp1, tmp2)
  1978. c.freeTemp(tmp1)
  1979. c.freeTemp(tmp2)
  1980. if dest >= 0:
  1981. gABC(c, n, whichAsgnOpc(n), dest, tmp0)
  1982. c.freeTemp(tmp0)
  1983. else:
  1984. dest = tmp0
  1985. of nkEmpty, nkCommentStmt, nkTypeSection, nkConstSection, nkPragma,
  1986. nkTemplateDef, nkIncludeStmt, nkImportStmt, nkFromStmt, nkExportStmt,
  1987. nkMixinStmt, nkBindStmt:
  1988. unused(c, n, dest)
  1989. of nkStringToCString, nkCStringToString:
  1990. gen(c, n[0], dest)
  1991. of nkBracket: genArrayConstr(c, n, dest)
  1992. of nkCurly: genSetConstr(c, n, dest)
  1993. of nkObjConstr: genObjConstr(c, n, dest)
  1994. of nkPar, nkClosure, nkTupleConstr: genTupleConstr(c, n, dest)
  1995. of nkCast:
  1996. if allowCast in c.features:
  1997. genConv(c, n, n[1], dest, opcCast)
  1998. else:
  1999. genCastIntFloat(c, n, dest)
  2000. of nkTypeOfExpr:
  2001. genTypeLit(c, n.typ, dest)
  2002. of nkComesFrom:
  2003. discard "XXX to implement for better stack traces"
  2004. else:
  2005. if n.typ != nil and n.typ.isCompileTimeOnly:
  2006. genTypeLit(c, n.typ, dest)
  2007. else:
  2008. globalError(c.config, n.info, "cannot generate VM code for " & $n)
  2009. proc removeLastEof(c: PCtx) =
  2010. let last = c.code.len-1
  2011. if last >= 0 and c.code[last].opcode == opcEof:
  2012. # overwrite last EOF:
  2013. assert c.code.len == c.debug.len
  2014. c.code.setLen(last)
  2015. c.debug.setLen(last)
  2016. proc genStmt*(c: PCtx; n: PNode): int =
  2017. c.removeLastEof
  2018. result = c.code.len
  2019. var d: TDest = -1
  2020. c.gen(n, d)
  2021. c.gABC(n, opcEof)
  2022. if d >= 0:
  2023. globalError(c.config, n.info, "VM problem: dest register is set")
  2024. proc genExpr*(c: PCtx; n: PNode, requiresValue = true): int =
  2025. c.removeLastEof
  2026. result = c.code.len
  2027. var d: TDest = -1
  2028. c.gen(n, d)
  2029. if d < 0:
  2030. if requiresValue:
  2031. globalError(c.config, n.info, "VM problem: dest register is not set")
  2032. d = 0
  2033. c.gABC(n, opcEof, d)
  2034. #echo renderTree(n)
  2035. #c.echoCode(result)
  2036. proc genParams(c: PCtx; params: PNode) =
  2037. # res.sym.position is already 0
  2038. setLen(c.prc.regInfo, max(params.len, 1))
  2039. c.prc.regInfo[0] = (inUse: true, kind: slotFixedVar)
  2040. for i in 1..<params.len:
  2041. c.prc.regInfo[i] = (inUse: true, kind: slotFixedLet)
  2042. proc finalJumpTarget(c: PCtx; pc, diff: int) =
  2043. internalAssert(c.config, regBxMin < diff and diff < regBxMax)
  2044. let oldInstr = c.code[pc]
  2045. # opcode and regA stay the same:
  2046. c.code[pc] = ((oldInstr.TInstrType and ((regOMask shl regOShift) or (regAMask shl regAShift))).TInstrType or
  2047. TInstrType(diff+wordExcess) shl regBxShift).TInstr
  2048. proc genGenericParams(c: PCtx; gp: PNode) =
  2049. var base = c.prc.regInfo.len
  2050. setLen c.prc.regInfo, base + gp.len
  2051. for i in 0..<gp.len:
  2052. var param = gp[i].sym
  2053. param.position = base + i # XXX: fix this earlier; make it consistent with templates
  2054. c.prc.regInfo[base + i] = (inUse: true, kind: slotFixedLet)
  2055. proc optimizeJumps(c: PCtx; start: int) =
  2056. const maxIterations = 10
  2057. for i in start..<c.code.len:
  2058. let opc = c.code[i].opcode
  2059. case opc
  2060. of opcTJmp, opcFJmp:
  2061. var reg = c.code[i].regA
  2062. var d = i + c.code[i].jmpDiff
  2063. for iters in countdown(maxIterations, 0):
  2064. case c.code[d].opcode
  2065. of opcJmp:
  2066. d += c.code[d].jmpDiff
  2067. of opcTJmp, opcFJmp:
  2068. if c.code[d].regA != reg: break
  2069. # tjmp x, 23
  2070. # ...
  2071. # tjmp x, 12
  2072. # -- we know 'x' is true, and so can jump to 12+13:
  2073. if c.code[d].opcode == opc:
  2074. d += c.code[d].jmpDiff
  2075. else:
  2076. # tjmp x, 23
  2077. # fjmp x, 22
  2078. # We know 'x' is true so skip to the next instruction:
  2079. d += 1
  2080. else: break
  2081. if d != i + c.code[i].jmpDiff:
  2082. c.finalJumpTarget(i, d - i)
  2083. of opcJmp, opcJmpBack:
  2084. var d = i + c.code[i].jmpDiff
  2085. var iters = maxIterations
  2086. while c.code[d].opcode == opcJmp and iters > 0:
  2087. d += c.code[d].jmpDiff
  2088. dec iters
  2089. if c.code[d].opcode == opcRet:
  2090. # optimize 'jmp to ret' to 'ret' here
  2091. c.code[i] = c.code[d]
  2092. elif d != i + c.code[i].jmpDiff:
  2093. c.finalJumpTarget(i, d - i)
  2094. else: discard
  2095. proc genProc(c: PCtx; s: PSym): int =
  2096. let
  2097. pos = c.procToCodePos.getOrDefault(s.id)
  2098. wasNotGenProcBefore = pos == 0
  2099. noRegistersAllocated = s.offset == -1
  2100. if wasNotGenProcBefore or noRegistersAllocated:
  2101. # xxx: the noRegisterAllocated check is required in order to avoid issues
  2102. # where nimsuggest can crash due as a macro with pos will be loaded
  2103. # but it doesn't have offsets for register allocations see:
  2104. # https://github.com/nim-lang/Nim/issues/18385
  2105. # Improvements and further use of IC should remove the need for this.
  2106. #if s.name.s == "outterMacro" or s.name.s == "innerProc":
  2107. # echo "GENERATING CODE FOR ", s.name.s
  2108. let last = c.code.len-1
  2109. var eofInstr: TInstr
  2110. if last >= 0 and c.code[last].opcode == opcEof:
  2111. eofInstr = c.code[last]
  2112. c.code.setLen(last)
  2113. c.debug.setLen(last)
  2114. #c.removeLastEof
  2115. result = c.code.len+1 # skip the jump instruction
  2116. c.procToCodePos[s.id] = result
  2117. # thanks to the jmp we can add top level statements easily and also nest
  2118. # procs easily:
  2119. let body = transformBody(c.graph, c.idgen, s, if isCompileTimeProc(s): dontUseCache else: useCache)
  2120. let procStart = c.xjmp(body, opcJmp, 0)
  2121. var p = PProc(blocks: @[], sym: s)
  2122. let oldPrc = c.prc
  2123. c.prc = p
  2124. # iterate over the parameters and allocate space for them:
  2125. genParams(c, s.typ.n)
  2126. # allocate additional space for any generically bound parameters
  2127. if s.kind == skMacro and s.isGenericRoutineStrict:
  2128. genGenericParams(c, s.ast[genericParamsPos])
  2129. if tfCapturesEnv in s.typ.flags:
  2130. #let env = s.ast[paramsPos].lastSon.sym
  2131. #assert env.position == 2
  2132. c.prc.regInfo.add (inUse: true, kind: slotFixedLet)
  2133. gen(c, body)
  2134. # generate final 'return' statement:
  2135. c.gABC(body, opcRet)
  2136. c.patch(procStart)
  2137. c.gABC(body, opcEof, eofInstr.regA)
  2138. c.optimizeJumps(result)
  2139. s.offset = c.prc.regInfo.len
  2140. #if s.name.s == "main" or s.name.s == "[]":
  2141. # echo renderTree(body)
  2142. # c.echoCode(result)
  2143. c.prc = oldPrc
  2144. else:
  2145. c.prc.regInfo.setLen s.offset
  2146. result = pos