# Can Julia access Memory locations or Registers directly
**URL:** https://discourse.julialang.org/t/can-julia-access-memory-locations-or-registers-directly/67016
**Category:** General Usage
**Tags:** question
**Created:** [August 26, 2021, 4:24am UTC](https://discourse.julialang.org/t/can-julia-access-memory-locations-or-registers-directly/67016 "2021-08-26T04:24:28Z")
**Posts on this page:** 13
**Page:** 1
### Author:  [@R.T.A.M](https://discourse.julialang.org/u/R.T.A.M)
#### Post date: [August 26, 2021, 4:24am UTC](https://discourse.julialang.org/t/can-julia-access-memory-locations-or-registers-directly/67016/1 "2021-08-26T04:24:28Z")
Hi all, I’m after some advice on low level memory access.
What is the best way to access (read or write) to individual registers in an embedded application with Julia?
Say I want to read address 0x6000 0000 plus an offset from there to confirm a pin driver configuration. Is there a Julia instruction to read an address directly?
---
### Author:  [@kristoffer.carlsson](https://discourse.julialang.org/u/kristoffer.carlsson)
#### Post date: [August 26, 2021, 5:05am UTC](https://discourse.julialang.org/t/can-julia-access-memory-locations-or-registers-directly/67016/2 "2021-08-26T05:05:20Z")
`unsafe_read` might be what you are looking for.
---
### Author:  [@R.T.A.M](https://discourse.julialang.org/u/R.T.A.M)
#### Post date: [August 26, 2021, 5:08am UTC](https://discourse.julialang.org/t/can-julia-access-memory-locations-or-registers-directly/67016/3 "2021-08-26T05:08:25Z")
Nice lead! I’ll check it out, thanks.
---
### Author:  [@maleadt](https://discourse.julialang.org/u/maleadt)
#### Post date: [August 26, 2021, 7:02am UTC](https://discourse.julialang.org/t/can-julia-access-memory-locations-or-registers-directly/67016/4 "2021-08-26T07:02:13Z")
> [@R.T.A.M](#):
>
> Say I want to read address 0x6000 0000 plus an offset from there to confirm a pin driver configuration. Is there a Julia instruction to read an address directly?
`unsafe_load` seems suitable for this.
---
### Author:  [@anon56330260](https://discourse.julialang.org/u/anon56330260)
#### Post date: [August 26, 2021, 7:48am UTC](https://discourse.julialang.org/t/can-julia-access-memory-locations-or-registers-directly/67016/5 "2021-08-26T07:48:07Z")
If you want to use pointer, then
```julia
offset = ...
p = Ptr{Nothing}(0x60000000 + offset) # build a void* pointer
Base.unsafe_convert(Ptr{...},p) # convert the pointer to a given type
Base.unsafe_load(p) # load the value from the pointer
```
If you want to read or write registers directly, I guess the best you can do is to use LLVM’s assembler expressions, check [LLVM’s documentation](https://llvm.org/docs/LangRef.html#inline-assembler-expressions).
---
### Author:  [@maleadt](https://discourse.julialang.org/u/maleadt)
#### Post date: [August 26, 2021, 7:59am UTC](https://discourse.julialang.org/t/can-julia-access-memory-locations-or-registers-directly/67016/6 "2021-08-26T07:59:53Z")
> [@anon56330260](#):
>
> If you want to read or write registers directly, I guess the best you can do is to use LLVM’s assembler expressions, check [LLVM’s documentation](https://llvm.org/docs/LangRef.html#inline-assembler-expressions).
And to use these from Julia, you can write your own `llvmcall` expressions, or use LLVM.jl. An example from CUDA.jl:
```julia
using LLVM
using LLVM.interop
dynamic_smem_size() = @asmcall("mov.u32 \$0, %dynamic_smem_size;", "=r", true, UInt32, Tuple{})
```
---
### Author:  [@R.T.A.M](https://discourse.julialang.org/u/R.T.A.M)
#### Post date: [August 26, 2021, 10:25am UTC](https://discourse.julialang.org/t/can-julia-access-memory-locations-or-registers-directly/67016/7 "2021-08-26T10:25:05Z")
Thanks Chen,
I tried p = Ptr{Nothing}(0x60000000 + offset) but this gives a Method error: no method matching Ptr{Nothing}(::UInt32)
But p=Ptr{Nothing}() is accepted, and returns Ptr{Nothing} @0x0000000000000000
If it works elsewhere, is there a package required?
---
### Author:  [@R.T.A.M](https://discourse.julialang.org/u/R.T.A.M)
#### Post date: [August 26, 2021, 10:32am UTC](https://discourse.julialang.org/t/can-julia-access-memory-locations-or-registers-directly/67016/8 "2021-08-26T10:32:04Z")
Thanks Tim,
I’ll put LLVM in my “plan B” tray while I try out the unsafe\_ Ptr permutations.
---
### Author:  [@Gnimuc](https://discourse.julialang.org/u/Gnimuc)
#### Post date: [August 26, 2021, 10:48am UTC](https://discourse.julialang.org/t/can-julia-access-memory-locations-or-registers-directly/67016/9 "2021-08-26T10:48:03Z")
Looks like you’re working on a 64bit system where a pointer is of 64 bits ( it has the same size as a 64bit integer and can be safely casted from a 64bit integer, but not from a 32bit integer), so you need to use `Ptr{Nothing}(0x6000000000000000)` instead.
---
### Author:  [@R.T.A.M](https://discourse.julialang.org/u/R.T.A.M)
#### Post date: [August 26, 2021, 10:49am UTC](https://discourse.julialang.org/t/can-julia-access-memory-locations-or-registers-directly/67016/10 "2021-08-26T10:49:27Z")
But…p=Ptr{Nothing}(0x0000000060000000) is accepted and returns
Ptr{Nothing} @0x0000000060000000
Yay!
Its a Jetson Nano.
---
### Author:  [@R.T.A.M](https://discourse.julialang.org/u/R.T.A.M)
#### Post date: [August 26, 2021, 10:50am UTC](https://discourse.julialang.org/t/can-julia-access-memory-locations-or-registers-directly/67016/11 "2021-08-26T10:50:05Z")
You’re right, that was accepted.
---
### Author:  [@R.T.A.M](https://discourse.julialang.org/u/R.T.A.M)
#### Post date: [August 26, 2021, 11:24am UTC](https://discourse.julialang.org/t/can-julia-access-memory-locations-or-registers-directly/67016/12 "2021-08-26T11:24:13Z")
Progress so far…
julia\> offset = 0x3230
0x3230
julia\> p=Ptr{Nothing}(0x0000000060000000 + offset)
Ptr{Nothing} @0x0000000060003230
julia\> pc=Base.unsafe\_convert(Ptr{UInt64},p)
Ptr{UInt64} @0x0000000060003230
julia\> regval=Base.unsafe\_load(pc)
signal (11): Segmentation fault
in expression starting at REPL[4]:1
unsafe\_load at ./pointer.jl:105 [inlined]
unsafe\_load at ./pointer.jl:105
unknown function (ip: 0x7f62395faf)
Allocations: 2650 (Pool: 2639; Big: 11); GC: 0
Segmentation fault (core dumped)
&Dumped, as expected.&
---
### Author:  [@anon56330260](https://discourse.julialang.org/u/anon56330260)
#### Post date: [August 26, 2021, 12:32pm UTC](https://discourse.julialang.org/t/can-julia-access-memory-locations-or-registers-directly/67016/13 "2021-08-26T12:32:59Z")
Maybe you should first test whether the equivalent C program works, like:
```julia
#include
int main(){
unsigned long a = 0x0000000060003230;
unsigned long *p = (unsigned long *)(a);
printf("%d\n",*p);
return 0;
};
```
I guess the problem here is that we need system calls to perform these IO actions (that is, confirm a pin driver configuration), instead of directly load values from the memory. Or the memory address is the mapped one…
It would be easier if you can just wrap these kinds of low level codes in C and provide the utility as a dynamic library, so you can directly call it from Julia instead of twisting pointers directly in Julia…