also handle cast to/from pointer

compiler/vm.nim

@@ -616,6 +616,9 @@ proc rawExecute(c: PCtx, start: int, tos: PStackFrame): TFullReg =
             stackTrace(c, tos, pc, "opcCastPtrToInt: " & $regs[rb].node.kind)
         of rkNodeAddr:
           regs[ra].intVal = cast[int](regs[rb].nodeAddr)
+        of rkInt:
+          # could be tightened by checking type, eg `tyPointer`
+          regs[ra].intVal = regs[rb].intVal
         else:
           stackTrace(c, tos, pc, "opcCastPtrToInt: got " & $regs[rb].kind)
       of 2: # tyRef
@@ -1011,6 +1014,8 @@ proc rawExecute(c: PCtx, start: int, tos: PStackFrame): TFullReg =
           ret = ptrEquality(regs[rb].nodeAddr, regs[rc].node)
       elif regs[rc].kind == rkNodeAddr:
         ret = ptrEquality(regs[rc].nodeAddr, regs[rb].node)
+      elif regs[rc].kind == rkInt and regs[rb].kind == rkInt:
+        ret = regs[rb].intVal == regs[rc].intVal
       else:
         let nb = regs[rb].node
         let nc = regs[rc].node

compiler/vmgen.nim

@@ -889,14 +889,14 @@ proc genCastIntFloat(c: PCtx; n: PNode; dest: var TDest) =
       c.gABC(n, opcCastFloatToInt64, dest, tmp)
       # narrowing for 64 bits not needed (no extended sign bits available).
     c.freeTemp(tmp)
-  elif src.kind in PtrLikeKinds + {tyRef} and dst.kind == tyInt:
+  elif src.kind in PtrLikeKinds + {tyRef} and dst.kind in {tyInt, tyPointer}:
     let tmp = c.genx(n[1])
     if dest < 0: dest = c.getTemp(n[0].typ)
     var imm: BiggestInt = if src.kind in PtrLikeKinds: 1 else: 2
     c.gABI(n, opcCastPtrToInt, dest, tmp, imm)
     c.freeTemp(tmp)
   elif (src.kind in PtrLikeKinds and dst.kind in PtrLikeKinds) or
-    (src.kind == tyInt and dst.kind in PtrLikeKinds + {tyRef}):
+    (src.kind in {tyInt, tyPointer} and dst.kind in PtrLikeKinds + {tyRef}):
     let tmp = c.genx(n[1])
     if dest < 0: dest = c.getTemp(n[0].typ)
     c.gABx(n, opcSetType, dest, c.genType(dst))

tests/vm/tcastint.nim

@@ -291,32 +291,36 @@ proc test_float32_castB() =
 proc testCastRefOrPtr() =
   type TFoo = object
     f0: string
-
-  template fn(Foo, a) =
-    let pa = cast[int](a)
-    var a2 = cast[Foo](pa)
-    let pa2 = cast[int](pa)
-    doAssert a2[] == a[]
-    doAssert a2.f0 == a.f0
-    doAssert pa2 == pa
-
-    a2.f0 = "abc2"
-    doAssert a.f0 == "abc2"
-    let b = TFoo(f0: "abc3")
-    a2[] = b
-    doAssert a2.f0 == "abc3"
-    doAssert a2[] == b
-
-  block: # ref <=> int
-    type Foo = ref TFoo
-    var a = Foo(f0: "abc")
-    fn(Foo, a)
-
-  block: # ptr <=> int
-    type Foo = ptr TFoo
-    var a0 = TFoo(f0: "abc")
-    let a = a0.addr
-    fn(Foo, a)
+  template fnAux(Lhs) =
+    block:
+      template fn(Foo, a) =
+        let pa = cast[Lhs](a)
+        var a2 = cast[Foo](pa)
+        let pa2 = cast[Lhs](pa)
+        doAssert a2[] == a[]
+        doAssert a2.f0 == a.f0
+        doAssert pa2 == pa
+
+        a2.f0 = "abc2"
+        doAssert a.f0 == "abc2"
+        let b = TFoo(f0: "abc3")
+        a2[] = b
+        doAssert a2.f0 == "abc3"
+        doAssert a2[] == b
+
+      block: # ref <=> Lhs
+        type Foo = ref TFoo
+        var a = Foo(f0: "abc")
+        fn(Foo, a)
+
+      block: # ptr <=> Lhs
+        type Foo = ptr TFoo
+        var a0 = TFoo(f0: "abc")
+        let a = a0.addr
+        fn(Foo, a)
+
+  fnAux(int)
+  fnAux(pointer)
 
 template main =
   test()