mirror of
https://github.com/denoland/deno.git
synced 2025-10-02 15:14:33 +00:00
feat(ext/ffi): implement UnsafePointer and UnsafePointerView (#12828)
This commit is contained in:
Elias Sjögreen
GitHub
parent
4d176b7b7c
commit
ee49cce726
9 changed files with 591 additions and 52 deletions
|
|
@ -6,7 +6,142 @@
|
|||
const __bootstrap = window.__bootstrap;
|
||||
const {
|
||||
ArrayBuffer,
|
||||
Uint8Array,
|
||||
BigInt,
|
||||
Number,
|
||||
TypeError,
|
||||
} = window.__bootstrap.primordials;
|
||||
|
||||
function unpackU64([hi, lo]) {
|
||||
return BigInt(hi) << 32n | BigInt(lo);
|
||||
}
|
||||
|
||||
function packU64(value) {
|
||||
return [Number(value >> 32n), Number(value & 0xFFFFFFFFn)];
|
||||
}
|
||||
|
||||
function unpackI64([hi, lo]) {
|
||||
const u64 = unpackU64([hi, lo]);
|
||||
return u64 >> 63n ? u64 - 0x10000000000000000n : u64;
|
||||
}
|
||||
|
||||
class UnsafePointerView {
|
||||
pointer;
|
||||
|
||||
constructor(pointer) {
|
||||
this.pointer = pointer;
|
||||
}
|
||||
|
||||
getUint8(offset = 0) {
|
||||
return core.opSync(
|
||||
"op_ffi_read_u8",
|
||||
packU64(this.pointer.value + BigInt(offset)),
|
||||
);
|
||||
}
|
||||
|
||||
getInt8(offset = 0) {
|
||||
return core.opSync(
|
||||
"op_ffi_read_i8",
|
||||
packU64(this.pointer.value + BigInt(offset)),
|
||||
);
|
||||
}
|
||||
|
||||
getUint16(offset = 0) {
|
||||
return core.opSync(
|
||||
"op_ffi_read_u16",
|
||||
packU64(this.pointer.value + BigInt(offset)),
|
||||
);
|
||||
}
|
||||
|
||||
getInt16(offset = 0) {
|
||||
return core.opSync(
|
||||
"op_ffi_read_i16",
|
||||
packU64(this.pointer.value + BigInt(offset)),
|
||||
);
|
||||
}
|
||||
|
||||
getUint32(offset = 0) {
|
||||
return core.opSync(
|
||||
"op_ffi_read_u32",
|
||||
packU64(this.pointer.value + BigInt(offset)),
|
||||
);
|
||||
}
|
||||
|
||||
getInt32(offset = 0) {
|
||||
return core.opSync(
|
||||
"op_ffi_read_i32",
|
||||
packU64(this.pointer.value + BigInt(offset)),
|
||||
);
|
||||
}
|
||||
|
||||
getBigUint64(offset = 0) {
|
||||
return unpackU64(core.opSync(
|
||||
"op_ffi_read_u64",
|
||||
packU64(this.pointer.value + BigInt(offset)),
|
||||
));
|
||||
}
|
||||
|
||||
getBigInt64(offset = 0) {
|
||||
return unpackI64(core.opSync(
|
||||
"op_ffi_read_u64",
|
||||
packU64(this.pointer.value + BigInt(offset)),
|
||||
));
|
||||
}
|
||||
|
||||
getFloat32(offset = 0) {
|
||||
return core.opSync(
|
||||
"op_ffi_read_f32",
|
||||
packU64(this.pointer.value + BigInt(offset)),
|
||||
);
|
||||
}
|
||||
|
||||
getFloat64(offset = 0) {
|
||||
return core.opSync(
|
||||
"op_ffi_read_f64",
|
||||
packU64(this.pointer.value + BigInt(offset)),
|
||||
);
|
||||
}
|
||||
|
||||
getCString(offset = 0) {
|
||||
return core.opSync(
|
||||
"op_ffi_cstr_read",
|
||||
packU64(this.pointer.value + BigInt(offset)),
|
||||
);
|
||||
}
|
||||
|
||||
getArrayBuffer(byteLength, offset = 0) {
|
||||
const uint8array = new Uint8Array(byteLength);
|
||||
this.copyInto(uint8array, offset);
|
||||
return uint8array.buffer;
|
||||
}
|
||||
|
||||
copyInto(destination, offset = 0) {
|
||||
core.opSync("op_ffi_buf_copy_into", [
|
||||
packU64(this.pointer.value + BigInt(offset)),
|
||||
destination,
|
||||
destination.byteLength,
|
||||
]);
|
||||
}
|
||||
}
|
||||
|
||||
class UnsafePointer {
|
||||
value;
|
||||
|
||||
constructor(value) {
|
||||
this.value = value;
|
||||
}
|
||||
|
||||
static of(typedArray) {
|
||||
return new UnsafePointer(
|
||||
unpackU64(core.opSync("op_ffi_ptr_of", typedArray)),
|
||||
);
|
||||
}
|
||||
|
||||
valueOf() {
|
||||
return this.value;
|
||||
}
|
||||
}
|
||||
|
||||
class DynamicLibrary {
|
||||
#rid;
|
||||
symbols = {};
|
||||
|
|
@ -16,37 +151,67 @@
|
|||
|
||||
for (const symbol in symbols) {
|
||||
const isNonBlocking = symbols[symbol].nonblocking;
|
||||
const types = symbols[symbol].parameters;
|
||||
|
||||
this.symbols[symbol] = (...args) => {
|
||||
const parameters = [];
|
||||
const buffers = [];
|
||||
|
||||
for (const arg of args) {
|
||||
if (
|
||||
arg?.buffer instanceof ArrayBuffer &&
|
||||
arg.byteLength !== undefined
|
||||
) {
|
||||
parameters.push(buffers.length);
|
||||
buffers.push(arg);
|
||||
for (let i = 0; i < types.length; i++) {
|
||||
const type = types[i];
|
||||
const arg = args[i];
|
||||
|
||||
if (type === "pointer") {
|
||||
if (
|
||||
arg?.buffer instanceof ArrayBuffer &&
|
||||
arg.byteLength !== undefined
|
||||
) {
|
||||
parameters.push(buffers.length);
|
||||
buffers.push(arg);
|
||||
} else if (arg instanceof UnsafePointer) {
|
||||
parameters.push(packU64(arg.value));
|
||||
buffers.push(undefined);
|
||||
} else if (arg === null) {
|
||||
parameters.push(null);
|
||||
buffers.push(undefined);
|
||||
} else {
|
||||
throw new TypeError(
|
||||
"Invalid ffi arg value, expected TypedArray, UnsafePointer or null",
|
||||
);
|
||||
}
|
||||
} else {
|
||||
parameters.push(arg);
|
||||
}
|
||||
}
|
||||
|
||||
if (isNonBlocking) {
|
||||
return core.opAsync("op_ffi_call_nonblocking", {
|
||||
const promise = core.opAsync("op_ffi_call_nonblocking", {
|
||||
rid: this.#rid,
|
||||
symbol,
|
||||
parameters,
|
||||
buffers,
|
||||
});
|
||||
|
||||
if (symbols[symbol].result === "pointer") {
|
||||
return promise.then((value) =>
|
||||
new UnsafePointer(unpackU64(value))
|
||||
);
|
||||
}
|
||||
|
||||
return promise;
|
||||
} else {
|
||||
return core.opSync("op_ffi_call", {
|
||||
const result = core.opSync("op_ffi_call", {
|
||||
rid: this.#rid,
|
||||
symbol,
|
||||
parameters,
|
||||
buffers,
|
||||
});
|
||||
|
||||
if (symbols[symbol].result === "pointer") {
|
||||
return new UnsafePointer(unpackU64(result));
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
};
|
||||
}
|
||||
|
|
@ -63,5 +228,5 @@
|
|||
return new DynamicLibrary(pathFromURL(path), symbols);
|
||||
}
|
||||
|
||||
window.__bootstrap.ffi = { dlopen };
|
||||
window.__bootstrap.ffi = { dlopen, UnsafePointer, UnsafePointerView };
|
||||
})(this);
|
||||
|
|
|
|||
269
ext/ffi/lib.rs
269
ext/ffi/lib.rs
|
|
@ -1,10 +1,12 @@
|
|||
// Copyright 2021 the Deno authors. All rights reserved. MIT license.
|
||||
|
||||
use deno_core::error::bad_resource_id;
|
||||
use deno_core::error::range_error;
|
||||
use deno_core::error::AnyError;
|
||||
use deno_core::include_js_files;
|
||||
use deno_core::op_async;
|
||||
use deno_core::op_sync;
|
||||
use deno_core::serde_json;
|
||||
use deno_core::serde_json::json;
|
||||
use deno_core::serde_json::Value;
|
||||
use deno_core::Extension;
|
||||
|
|
@ -15,12 +17,15 @@ use deno_core::ZeroCopyBuf;
|
|||
use dlopen::raw::Library;
|
||||
use libffi::middle::Arg;
|
||||
use serde::Deserialize;
|
||||
use serde::Serialize;
|
||||
use std::borrow::Cow;
|
||||
use std::cell::RefCell;
|
||||
use std::collections::HashMap;
|
||||
use std::ffi::c_void;
|
||||
use std::ffi::CStr;
|
||||
use std::path::Path;
|
||||
use std::path::PathBuf;
|
||||
use std::ptr;
|
||||
use std::rc::Rc;
|
||||
|
||||
pub struct Unstable(pub bool);
|
||||
|
|
@ -38,7 +43,7 @@ fn check_unstable(state: &OpState, api_name: &str) {
|
|||
}
|
||||
|
||||
pub trait FfiPermissions {
|
||||
fn check(&mut self, path: &Path) -> Result<(), AnyError>;
|
||||
fn check(&mut self, path: Option<&Path>) -> Result<(), AnyError>;
|
||||
}
|
||||
|
||||
#[derive(Clone)]
|
||||
|
|
@ -108,6 +113,18 @@ pub fn init<P: FfiPermissions + 'static>(unstable: bool) -> Extension {
|
|||
("op_ffi_load", op_sync(op_ffi_load::<P>)),
|
||||
("op_ffi_call", op_sync(op_ffi_call)),
|
||||
("op_ffi_call_nonblocking", op_async(op_ffi_call_nonblocking)),
|
||||
("op_ffi_ptr_of", op_sync(op_ffi_ptr_of::<P>)),
|
||||
("op_ffi_buf_copy_into", op_sync(op_ffi_buf_copy_into::<P>)),
|
||||
("op_ffi_cstr_read", op_sync(op_ffi_cstr_read::<P>)),
|
||||
("op_ffi_read_u8", op_sync(op_ffi_read_u8::<P>)),
|
||||
("op_ffi_read_i8", op_sync(op_ffi_read_i8::<P>)),
|
||||
("op_ffi_read_u16", op_sync(op_ffi_read_u16::<P>)),
|
||||
("op_ffi_read_i16", op_sync(op_ffi_read_i16::<P>)),
|
||||
("op_ffi_read_u32", op_sync(op_ffi_read_u32::<P>)),
|
||||
("op_ffi_read_i32", op_sync(op_ffi_read_i32::<P>)),
|
||||
("op_ffi_read_u64", op_sync(op_ffi_read_u64::<P>)),
|
||||
("op_ffi_read_f32", op_sync(op_ffi_read_f32::<P>)),
|
||||
("op_ffi_read_f64", op_sync(op_ffi_read_f64::<P>)),
|
||||
])
|
||||
.state(move |state| {
|
||||
// Stolen from deno_webgpu, is there a better option?
|
||||
|
|
@ -133,7 +150,7 @@ enum NativeType {
|
|||
ISize,
|
||||
F32,
|
||||
F64,
|
||||
Buffer,
|
||||
Pointer,
|
||||
}
|
||||
|
||||
impl From<NativeType> for libffi::middle::Type {
|
||||
|
|
@ -152,7 +169,7 @@ impl From<NativeType> for libffi::middle::Type {
|
|||
NativeType::ISize => libffi::middle::Type::isize(),
|
||||
NativeType::F32 => libffi::middle::Type::f32(),
|
||||
NativeType::F64 => libffi::middle::Type::f64(),
|
||||
NativeType::Buffer => libffi::middle::Type::pointer(),
|
||||
NativeType::Pointer => libffi::middle::Type::pointer(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -172,7 +189,7 @@ union NativeValue {
|
|||
isize_value: isize,
|
||||
f32_value: f32,
|
||||
f64_value: f64,
|
||||
buffer: *const u8,
|
||||
pointer: *const u8,
|
||||
}
|
||||
|
||||
impl NativeValue {
|
||||
|
|
@ -215,12 +232,25 @@ impl NativeValue {
|
|||
NativeType::F64 => Self {
|
||||
f64_value: value_as_f64(value),
|
||||
},
|
||||
NativeType::Buffer => unreachable!(),
|
||||
NativeType::Pointer => {
|
||||
if value.is_null() {
|
||||
Self {
|
||||
pointer: ptr::null(),
|
||||
}
|
||||
} else {
|
||||
Self {
|
||||
pointer: u64::from(
|
||||
serde_json::from_value::<U32x2>(value)
|
||||
.expect("Expected ffi arg value to be a tuple of the low and high bits of a pointer address")
|
||||
) as *const u8,
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn buffer(ptr: *const u8) -> Self {
|
||||
Self { buffer: ptr }
|
||||
Self { pointer: ptr }
|
||||
}
|
||||
|
||||
unsafe fn as_arg(&self, native_type: NativeType) -> Arg {
|
||||
|
|
@ -238,7 +268,7 @@ impl NativeValue {
|
|||
NativeType::ISize => Arg::new(&self.isize_value),
|
||||
NativeType::F32 => Arg::new(&self.f32_value),
|
||||
NativeType::F64 => Arg::new(&self.f64_value),
|
||||
NativeType::Buffer => Arg::new(&self.buffer),
|
||||
NativeType::Pointer => Arg::new(&self.pointer),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -267,6 +297,21 @@ fn value_as_f64(value: Value) -> f64 {
|
|||
.expect("Expected ffi arg value to be a float")
|
||||
}
|
||||
|
||||
#[derive(Serialize, Deserialize, Debug)]
|
||||
struct U32x2(u32, u32);
|
||||
|
||||
impl From<u64> for U32x2 {
|
||||
fn from(value: u64) -> Self {
|
||||
Self((value >> 32) as u32, value as u32)
|
||||
}
|
||||
}
|
||||
|
||||
impl From<U32x2> for u64 {
|
||||
fn from(value: U32x2) -> Self {
|
||||
(value.0 as u64) << 32 | value.1 as u64
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Deserialize, Debug)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
struct ForeignFunction {
|
||||
|
|
@ -367,7 +412,7 @@ where
|
|||
|
||||
check_unstable(state, "Deno.dlopen");
|
||||
let permissions = state.borrow_mut::<FP>();
|
||||
permissions.check(&PathBuf::from(&path))?;
|
||||
permissions.check(Some(&PathBuf::from(&path)))?;
|
||||
|
||||
let lib = Library::open(&path).map_err(|e| {
|
||||
dlopen::Error::OpeningLibraryError(std::io::Error::new(
|
||||
|
|
@ -394,25 +439,30 @@ struct FfiCallArgs {
|
|||
rid: ResourceId,
|
||||
symbol: String,
|
||||
parameters: Vec<Value>,
|
||||
buffers: Vec<ZeroCopyBuf>,
|
||||
buffers: Vec<Option<ZeroCopyBuf>>,
|
||||
}
|
||||
|
||||
fn ffi_call(args: FfiCallArgs, symbol: &Symbol) -> Result<Value, AnyError> {
|
||||
let buffers: Vec<&[u8]> =
|
||||
args.buffers.iter().map(|buffer| &buffer[..]).collect();
|
||||
let buffers: Vec<Option<&[u8]>> = args
|
||||
.buffers
|
||||
.iter()
|
||||
.map(|buffer| buffer.as_ref().map(|buffer| &buffer[..]))
|
||||
.collect();
|
||||
|
||||
let native_values = symbol
|
||||
.parameter_types
|
||||
.iter()
|
||||
.zip(args.parameters.into_iter())
|
||||
.map(|(&native_type, value)| {
|
||||
if let NativeType::Buffer = native_type {
|
||||
let idx: usize = value_as_uint(value);
|
||||
let ptr = buffers[idx].as_ptr();
|
||||
NativeValue::buffer(ptr)
|
||||
} else {
|
||||
NativeValue::new(native_type, value)
|
||||
if let NativeType::Pointer = native_type {
|
||||
if let Some(idx) = value.as_u64() {
|
||||
if let Some(&Some(buf)) = buffers.get(idx as usize) {
|
||||
return NativeValue::buffer(buf.as_ptr());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
NativeValue::new(native_type, value)
|
||||
})
|
||||
.collect::<Vec<_>>();
|
||||
|
||||
|
|
@ -465,7 +515,11 @@ fn ffi_call(args: FfiCallArgs, symbol: &Symbol) -> Result<Value, AnyError> {
|
|||
NativeType::F64 => {
|
||||
json!(unsafe { symbol.cif.call::<f64>(symbol.ptr, &call_args) })
|
||||
}
|
||||
NativeType::Buffer => unreachable!(),
|
||||
NativeType::Pointer => {
|
||||
json!(U32x2::from(unsafe {
|
||||
symbol.cif.call::<*const u8>(symbol.ptr, &call_args)
|
||||
} as u64))
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
|
|
@ -507,6 +561,185 @@ async fn op_ffi_call_nonblocking(
|
|||
.unwrap()
|
||||
}
|
||||
|
||||
fn op_ffi_ptr_of<FP>(
|
||||
state: &mut deno_core::OpState,
|
||||
buf: ZeroCopyBuf,
|
||||
_: (),
|
||||
) -> Result<U32x2, AnyError>
|
||||
where
|
||||
FP: FfiPermissions + 'static,
|
||||
{
|
||||
let permissions = state.borrow_mut::<FP>();
|
||||
permissions.check(None)?;
|
||||
|
||||
Ok(U32x2::from(buf.as_ptr() as u64))
|
||||
}
|
||||
|
||||
fn op_ffi_buf_copy_into<FP>(
|
||||
state: &mut deno_core::OpState,
|
||||
(src, mut dst, len): (U32x2, ZeroCopyBuf, usize),
|
||||
_: (),
|
||||
) -> Result<(), AnyError>
|
||||
where
|
||||
FP: FfiPermissions + 'static,
|
||||
{
|
||||
let permissions = state.borrow_mut::<FP>();
|
||||
permissions.check(None)?;
|
||||
|
||||
if dst.len() < len {
|
||||
Err(range_error(
|
||||
"Destination length is smaller than source length",
|
||||
))
|
||||
} else {
|
||||
let src = u64::from(src) as *const u8;
|
||||
unsafe { ptr::copy(src, dst.as_mut_ptr(), len) };
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
fn op_ffi_cstr_read<FP>(
|
||||
state: &mut deno_core::OpState,
|
||||
ptr: U32x2,
|
||||
_: (),
|
||||
) -> Result<String, AnyError>
|
||||
where
|
||||
FP: FfiPermissions + 'static,
|
||||
{
|
||||
let permissions = state.borrow_mut::<FP>();
|
||||
permissions.check(None)?;
|
||||
|
||||
let ptr = u64::from(ptr) as *const i8;
|
||||
Ok(unsafe { CStr::from_ptr(ptr) }.to_str()?.to_string())
|
||||
}
|
||||
|
||||
fn op_ffi_read_u8<FP>(
|
||||
state: &mut deno_core::OpState,
|
||||
ptr: U32x2,
|
||||
_: (),
|
||||
) -> Result<u8, AnyError>
|
||||
where
|
||||
FP: FfiPermissions + 'static,
|
||||
{
|
||||
let permissions = state.borrow_mut::<FP>();
|
||||
permissions.check(None)?;
|
||||
|
||||
Ok(unsafe { ptr::read_unaligned(u64::from(ptr) as *const u8) })
|
||||
}
|
||||
|
||||
fn op_ffi_read_i8<FP>(
|
||||
state: &mut deno_core::OpState,
|
||||
ptr: U32x2,
|
||||
_: (),
|
||||
) -> Result<i8, AnyError>
|
||||
where
|
||||
FP: FfiPermissions + 'static,
|
||||
{
|
||||
let permissions = state.borrow_mut::<FP>();
|
||||
permissions.check(None)?;
|
||||
|
||||
Ok(unsafe { ptr::read_unaligned(u64::from(ptr) as *const i8) })
|
||||
}
|
||||
|
||||
fn op_ffi_read_u16<FP>(
|
||||
state: &mut deno_core::OpState,
|
||||
ptr: U32x2,
|
||||
_: (),
|
||||
) -> Result<u16, AnyError>
|
||||
where
|
||||
FP: FfiPermissions + 'static,
|
||||
{
|
||||
let permissions = state.borrow_mut::<FP>();
|
||||
permissions.check(None)?;
|
||||
|
||||
Ok(unsafe { ptr::read_unaligned(u64::from(ptr) as *const u16) })
|
||||
}
|
||||
|
||||
fn op_ffi_read_i16<FP>(
|
||||
state: &mut deno_core::OpState,
|
||||
ptr: U32x2,
|
||||
_: (),
|
||||
) -> Result<i16, AnyError>
|
||||
where
|
||||
FP: FfiPermissions + 'static,
|
||||
{
|
||||
let permissions = state.borrow_mut::<FP>();
|
||||
permissions.check(None)?;
|
||||
|
||||
Ok(unsafe { ptr::read_unaligned(u64::from(ptr) as *const i16) })
|
||||
}
|
||||
|
||||
fn op_ffi_read_u32<FP>(
|
||||
state: &mut deno_core::OpState,
|
||||
ptr: U32x2,
|
||||
_: (),
|
||||
) -> Result<u32, AnyError>
|
||||
where
|
||||
FP: FfiPermissions + 'static,
|
||||
{
|
||||
let permissions = state.borrow_mut::<FP>();
|
||||
permissions.check(None)?;
|
||||
|
||||
Ok(unsafe { ptr::read_unaligned(u64::from(ptr) as *const u32) })
|
||||
}
|
||||
|
||||
fn op_ffi_read_i32<FP>(
|
||||
state: &mut deno_core::OpState,
|
||||
ptr: U32x2,
|
||||
_: (),
|
||||
) -> Result<i32, AnyError>
|
||||
where
|
||||
FP: FfiPermissions + 'static,
|
||||
{
|
||||
let permissions = state.borrow_mut::<FP>();
|
||||
permissions.check(None)?;
|
||||
|
||||
Ok(unsafe { ptr::read_unaligned(u64::from(ptr) as *const i32) })
|
||||
}
|
||||
|
||||
fn op_ffi_read_u64<FP>(
|
||||
state: &mut deno_core::OpState,
|
||||
ptr: U32x2,
|
||||
_: (),
|
||||
) -> Result<U32x2, AnyError>
|
||||
where
|
||||
FP: FfiPermissions + 'static,
|
||||
{
|
||||
let permissions = state.borrow_mut::<FP>();
|
||||
permissions.check(None)?;
|
||||
|
||||
Ok(U32x2::from(unsafe {
|
||||
ptr::read_unaligned(u64::from(ptr) as *const u64)
|
||||
}))
|
||||
}
|
||||
|
||||
fn op_ffi_read_f32<FP>(
|
||||
state: &mut deno_core::OpState,
|
||||
ptr: U32x2,
|
||||
_: (),
|
||||
) -> Result<f32, AnyError>
|
||||
where
|
||||
FP: FfiPermissions + 'static,
|
||||
{
|
||||
let permissions = state.borrow_mut::<FP>();
|
||||
permissions.check(None)?;
|
||||
|
||||
Ok(unsafe { ptr::read_unaligned(u64::from(ptr) as *const f32) })
|
||||
}
|
||||
|
||||
fn op_ffi_read_f64<FP>(
|
||||
state: &mut deno_core::OpState,
|
||||
ptr: U32x2,
|
||||
_: (),
|
||||
) -> Result<f64, AnyError>
|
||||
where
|
||||
FP: FfiPermissions + 'static,
|
||||
{
|
||||
let permissions = state.borrow_mut::<FP>();
|
||||
permissions.check(None)?;
|
||||
|
||||
Ok(unsafe { ptr::read_unaligned(u64::from(ptr) as *const f64) })
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
#[cfg(target_os = "windows")]
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue