const array indexing zeroes data in object variants at runtime

[mratsim]

Follow-up on #8007.

As a workaround to Tables losing compile-time object variant fields at runtime, I used arrays.

However after assigning a const array of object variant to a non-const variable, fields containing a proc pointer become nil.

Test case:

type
  CostKind = enum
    Fixed,
    Dynamic

  Cost = object
    case kind*: CostKind
    of Fixed:
      cost*: int
    of Dynamic:
      handler*: proc(): int {.nimcall.}

proc foo1(): int {.nimcall.} =
  100

proc foo2(): int {.nimcall.} =
  200

# Change to `let` and it doesn't crash
const costTable = [
  0: Cost(kind: Fixed, cost: 999),
  1: Cost(kind: Dynamic, handler: foo1),
  2: Cost(kind: Dynamic, handler: foo2)
]

##########################

echo cast[ByteAddress](costTable[1].handler) # A random address for example - 4497725824
echo cast[ByteAddress](costTable[2].handler) # 4497726128

echo costTable[0]           # (kind: Fixed, cost: 999)
echo costTable[1].handler() # 100
echo costTable[2].handler() # 200

##########################
# Now trying to carry the table as an object field

type
  Wrapper = object
    table: array[3, Cost]

proc procNewWrapper(): Wrapper =
  result.table = costTable


# Alternatively, change to `const` and it doesn't crash
let viaProc = procNewWrapper()

echo cast[ByteAddress](viaProc.table[1].handler) # Address is 0
echo cast[ByteAddress](viaProc.table[2].handler)

echo viaProc.table[0]           # (kind: Fixed, cost: 999)
echo viaProc.table[1].handler() # SIGSEGV
echo viaProc.table[2].handler()

No issue if:

• everything is done at compile-time
• everything is done at runtime
• we don't use object variant

Example without object variant

type
  Cost = proc(): int {.nimcall.}

proc foo1(): int {.nimcall.} =
  100

proc foo2(): int {.nimcall.} =
  200

# Change to `let` and it doesn't crash
const costTable = [
  0: foo1,
  1: foo1,
  2: foo2
]

##########################

echo cast[ByteAddress](costTable[1]()) # A random address for example - 4497725824
echo cast[ByteAddress](costTable[2]()) # 4497726128

echo costTable[1]() # 100
echo costTable[2]() # 200

##########################
# Now trying to carry the table as an object field

type
  Wrapper = ref object of RootObj # changing to object doesn't change anything here as well
    table: array[3, Cost]

proc procNewWrapper(): Wrapper =
  new result
  result.table = costTable

let viaProc = procNewWrapper()

echo cast[ByteAddress](viaProc.table[1]) # Address is 0
echo cast[ByteAddress](viaProc.table[2])

echo viaProc.table[1]() # SIGSEGV
echo viaProc.table[2]()

[jangko]

this is the generated code for costTable

NIM_CONST tyArray_WhU07q1GSgwZ2Yc60JIUlg costTable_sBUTwJc6CNeo5483rNsQhg = {{((tyEnum_CostKind_GGuYJIMY9aVFBKVS7j4CxtA) 0), ((NI) 999), NIM_NIL},
{((tyEnum_CostKind_GGuYJIMY9aVFBKVS7j4CxtA) 1), ((NI) 0), foo1_X2aQK4bCESQjARXX8182jQ},
{((tyEnum_CostKind_GGuYJIMY9aVFBKVS7j4CxtA) 1), ((NI) 0), foo2_X2aQK4bCESQjARXX8182jQ_2}}
;

((NI) 999), NIM_NIL} wrong!
((NI) 0), foo1_X2aQK4bCESQjARXX8182jQ} wrong!
((NI) 0), foo2_X2aQK4bCESQjARXX8182jQ_2} wrong!

why this code below not crash? because Nim compiler use literal value here, not taken from costTable

echo costTable[0]           # (kind: Fixed, cost: 999)
echo costTable[1].handler() # 100
echo costTable[2].handler() # 200

although the generated C code is wrong, the bug could be located somewhere else, not necessarily in codegen. But it is a starting point if someone decide to take a look.

[mratsim]

As reported in #9021 and https://forum.nim-lang.org/t/4773 for enums, all kind of fields lose data not only proc fields.

[Araq]

Const case objects never were supposed to compile, there is logic in the compiler to detect and reject that but as we can see it's not triggered.

[narimiran]

Current outputs (Nim devel 1.1.1) for the two examples in the original post:

94137662452323
94137662452460
(kind: Fixed, cost: 0)
100
200
94137662452323
94137662452460
(kind: Fixed, cost: 999)
100
200

100
200
100
200
94504683509470
94504683509607
100
200

(Notice cost: 0!)

[timotheecour]

seems related: #13081

[mratsim]

Just so people know, in many cases you can do const foo = static(yourProcOrCompileTimeVal) as a workaround to cross the compile-time/runtime boundary

[timotheecour]

even though other object variant bugs were recently fixed, this bug remains

minimal repro:

when true:
  import unittest
  type Foo = object
    case b: bool
    of false: v1: int
    of true: v2: int
  const t = [Foo(b: false, v1: 1), Foo(b: true, v2: 2)]
  check $t == "[(b: false, v1: 1), (b: true, v2: 2)]"
  check $t[0] == "(b: false, v1: 1)" # fails

fails as of 64016dd 1.5.1

echo costTable[0] # (kind: Fixed, cost: 999)

@mratsim I tried a few versions and never saw that, only (kind: Fixed, cost: 0)
(I'm on OSX)

Which git hash did you try it on? (this is why we need to show git hash in issue reports, always);

echo viaProc.table[1].handler() # SIGSEGV

doesn't crash anymore

[narimiran]

Both original examples and the example in the @timotheecour's comment above mine seem to work fine on the latest devel. Can you confirm?

[timotheecour]

Can you confirm?

indeed => #16782