{.volatile.} is almost useless

[rasendubi]

As an embedded and kernel developer I need pointers to a volatile memory to work with memory-mapped hardware registers. Nim has a {.volatile.} pragma but it's a property of a variable.

let reg {.volatile.} = cast[ptr char](0x101f1000)

gives the following C output:

NIM_CHAR* volatile reg;
nimfr("kmain", "kernel.nim");
nimln(5, "kernel.nim");
reg = ((NIM_CHAR*) 270471168);

As you see, reg is a volatile pointer to a non-volatile memory. The behavior I want to achieve is a non-volatile pointer to a volatile memory:

NIM_CHAR volatile *reg;

I don't see a way to create such a variable in Nim. I would say, that's pretty critical: embedded and kernel-level programming is impossible without that.

As a fix I think of making volatile a property of a type rather than a variable. I expect to write the following:

let reg = cast[ptr[char {.volatile.}]](0x101f1000)
# or even
const reg = cast[ptr[char {.volatile.}]](0x101f1000)
# const reg {.volatile.} = ... doesn't even work now

[yglukhov]

As a quick and dirty workaround you can use emit.

{.emit: "NIM_CHAR volatile* myPtr;".}
var myPtr {.nodecl, importc.}: ptr char
myPtr[] = 'A'

I guess this could be wrapped in a macro.

[rasendubi]

The other solution (from Rust: rust-lang/rust#11172) is to implement volatile_load and volatile_store functions.

[Araq]

Volatile is not a property of a type and should not be.

[Araq]

volatile_load and volatile_store is the superior solution indeed.

[jcosborn]

This seems to work. It involves an extra copy, but doesn't require any emits.

template volatileLoad*[T](p: ptr T): T =
  let x {.volatile.} = p[]
  x

template volatileStore*[T](p: ptr T, v: T) =
  let x {.volatile.} = v
  p[] = x

type VolatilePtr*[T] = distinct ptr T

template `[]`*[T](p: VolatilePtr[T]): T =
  volatileLoad((ptr T)(p))

template `[]=`*[T](p: VolatilePtr[T], v: T) =
  volatileStore((ptr T)(p), v)

when isMainModule:
  proc test =
    var t = 0
    var c = 0

    for i in 1..1000:
      volatileStore(addr t, 1)
      if volatileLoad(addr t)==1:
        inc c

    let p = VolatilePtr(addr t)

    for i in 1..1000:
      p[] = 2
      if p[]==2:
        inc c

    echo c

  test()