language-servers/roc
1
0
Fork 0
mirror of https://github.com/roc-lang/roc.git synced 2025-09-28 22:34:45 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 6

correct codegen for calling the extern

Browse source
This commit is contained in:
Folkert 2023-01-20 15:07:49 +01:00
parent 1ac2c2bb80
commit c622cebea6
No known key found for this signature in database
GPG key ID: 1F17F6FFD112B97C
4 changed files with 204 additions and 165 deletions
Download patch file Download diff file Expand all files Collapse all files

317
examples/platform-switching/rust-platform/src/glue.rs
View file

@ -59,6 +59,7 @@ pub struct Op {
pointer: *mut union_Op,
}
#[cfg(any(
target_arch = "arm",
target_arch = "aarch64",
@ -86,6 +87,7 @@ union union_Op {
target_arch = "x86_64"
))]
//TODO HAS CLOSURE 2
#[cfg(any(
target_arch = "arm",
target_arch = "aarch64",
@ -93,20 +95,20 @@ union union_Op {
target_arch = "x86",
target_arch = "x86_64"
))]
#[repr(C)]
pub struct RocFunction_65<'a> {
closure_data: *const u8,
_marker: std::marker::PhantomData<&'a ()>,
pub struct RocFunction_65 {
pub closure_data: *mut u8,
}
impl<'a> RocFunction_65<'a> {
pub fn force_thunk(self) -> Op {
impl RocFunction_65 {
pub fn force_thunk(self, arg_0: ()) -> Op {
extern "C" {
fn roc__mainForHost_1__Fx2_caller(output: *mut Op, input: *const u8);
fn roc__mainForHost_1__Fx2_caller(output: *mut Op, arg_0: (), closure_data: *mut u8);
}
let mut output = std::mem::MaybeUninit::uninit();
unsafe { roc__mainForHost_1__Fx2_caller(output.as_mut_ptr(), self.closure_data) };
unsafe { roc__mainForHost_1__Fx2_caller(output.as_mut_ptr(), arg_0, self.closure_data) };
unsafe { output.assume_init() }
}
}
@ -118,19 +120,20 @@ impl<'a> RocFunction_65<'a> {
target_arch = "x86",
target_arch = "x86_64"
))]
#[repr(C)]
pub struct RocFunction_67 {
pub closure_data: (),
pub closure_data: *mut u8,
}
impl RocFunction_67 {
pub fn force_thunk(self) -> Op {
pub fn force_thunk(self, arg_0: ()) -> Op {
extern "C" {
fn roc__mainForHost_1__Fx2_caller(output: *mut Op);
fn roc__mainForHost_1__Fx2_caller(output: *mut Op, arg_0: (), closure_data: *mut u8);
}
let mut output = std::mem::MaybeUninit::uninit();
unsafe { roc__mainForHost_1__Fx2_caller(output.as_mut_ptr()) };
unsafe { roc__mainForHost_1__Fx2_caller(output.as_mut_ptr(), arg_0, self.closure_data) };
unsafe { output.assume_init() }
}
}
@ -158,18 +161,28 @@ impl Op {
if untagged.is_null() {
None
} else {
unsafe { Some(&*untagged.sub(1)) }
unsafe {
Some(&*untagged.sub(1))
}
}
}
#[cfg(any(target_arch = "arm", target_arch = "wasm32", target_arch = "x86"))]
#[cfg(any(
target_arch = "arm",
target_arch = "wasm32",
target_arch = "x86"
))]
/// Returns which variant this tag union holds. Note that this never includes a payload!
pub fn discriminant(&self) -> discriminant_Op {
// The discriminant is stored in the unused bytes at the end of the recursive pointer
unsafe { core::mem::transmute::<u8, discriminant_Op>((self.pointer as u8) & 0b11) }
}
#[cfg(any(target_arch = "arm", target_arch = "wasm32", target_arch = "x86"))]
#[cfg(any(
target_arch = "arm",
target_arch = "wasm32",
target_arch = "x86"
))]
/// Internal helper
fn tag_discriminant(pointer: *mut union_Op, discriminant: discriminant_Op) -> *mut union_Op {
// The discriminant is stored in the unused bytes at the end of the union pointer
@ -179,7 +192,11 @@ impl Op {
tagged as *mut union_Op
}
#[cfg(any(target_arch = "arm", target_arch = "wasm32", target_arch = "x86"))]
#[cfg(any(
target_arch = "arm",
target_arch = "wasm32",
target_arch = "x86"
))]
/// Internal helper
fn union_pointer(&self) -> *mut union_Op {
// The discriminant is stored in the unused bytes at the end of the union pointer
@ -257,28 +274,32 @@ impl Op {
))]
/// Construct a tag named `StderrWrite`, with the appropriate payload
pub fn StderrWrite(arg: Op_StderrWrite) -> Self {
let size = core::mem::size_of::<union_Op>();
let align = core::mem::align_of::<union_Op>() as u32;
let size = core::mem::size_of::<union_Op>();
let align = core::mem::align_of::<union_Op>() as u32;
unsafe {
let ptr = roc_std::roc_alloc_refcounted::<union_Op>();
unsafe {
let ptr = roc_std::roc_alloc_refcounted::<union_Op>();
*ptr = union_Op {
StderrWrite: core::mem::ManuallyDrop::new(arg),
};
*ptr = union_Op {
StderrWrite: core::mem::ManuallyDrop::new(arg)
};
Self {
pointer: Self::tag_discriminant(ptr, discriminant_Op::StderrWrite),
Self {
pointer: Self::tag_discriminant(ptr, discriminant_Op::StderrWrite),
}
}
}
}
#[cfg(any(target_arch = "arm", target_arch = "wasm32", target_arch = "x86"))]
#[cfg(any(
target_arch = "arm",
target_arch = "wasm32",
target_arch = "x86"
))]
/// Unsafely assume this `Op` has a `.discriminant()` of `StderrWrite` and convert it to `StderrWrite`'s payload.
/// (Always examine `.discriminant()` first to make sure this is the correct variant!)
/// Panics in debug builds if the `.discriminant()` doesn't return `StderrWrite`.
pub unsafe fn into_StderrWrite(mut self) -> Op_StderrWrite {
debug_assert_eq!(self.discriminant(), discriminant_Op::StderrWrite);
/// (Always examine `.discriminant()` first to make sure this is the correct variant!)
/// Panics in debug builds if the `.discriminant()` doesn't return `StderrWrite`.
pub unsafe fn into_StderrWrite(mut self) -> Op_StderrWrite {
debug_assert_eq!(self.discriminant(), discriminant_Op::StderrWrite);
let payload = {
let ptr = (self.pointer as usize & !0b11) as *mut union_Op;
let mut uninitialized = core::mem::MaybeUninit::uninit();
@ -297,12 +318,16 @@ impl Op {
payload
}
#[cfg(any(target_arch = "arm", target_arch = "wasm32", target_arch = "x86"))]
#[cfg(any(
target_arch = "arm",
target_arch = "wasm32",
target_arch = "x86"
))]
/// Unsafely assume this `Op` has a `.discriminant()` of `StderrWrite` and return its payload.
/// (Always examine `.discriminant()` first to make sure this is the correct variant!)
/// Panics in debug builds if the `.discriminant()` doesn't return `StderrWrite`.
pub unsafe fn as_StderrWrite(&self) -> &Op_StderrWrite {
debug_assert_eq!(self.discriminant(), discriminant_Op::StderrWrite);
/// (Always examine `.discriminant()` first to make sure this is the correct variant!)
/// Panics in debug builds if the `.discriminant()` doesn't return `StderrWrite`.
pub unsafe fn as_StderrWrite(&self) -> &Op_StderrWrite {
debug_assert_eq!(self.discriminant(), discriminant_Op::StderrWrite);
let payload = {
let ptr = (self.pointer as usize & !0b11) as *mut union_Op;
@ -352,16 +377,14 @@ impl Op {
extern "C" {
#[link_name = "roc__getter__3"]
fn getter(_: *const Op) -> *const u8;
// fn getter(_: *mut RocFunction_65, _: *const Op);
fn getter(_: *mut RocFunction_65, _: *const Op);
}
let ptr = getter(self);
let mut ret = core::mem::MaybeUninit::uninit();
RocFunction_65 {
closure_data: ptr,
_marker: Default::default(),
}
getter(ret.as_mut_ptr(), self);
ret.assume_init()
}
#[cfg(any(
@ -373,28 +396,32 @@ impl Op {
))]
/// Construct a tag named `StdoutWrite`, with the appropriate payload
pub fn StdoutWrite(arg: Op_StdoutWrite) -> Self {
let size = core::mem::size_of::<union_Op>();
let align = core::mem::align_of::<union_Op>() as u32;
let size = core::mem::size_of::<union_Op>();
let align = core::mem::align_of::<union_Op>() as u32;
unsafe {
let ptr = roc_std::roc_alloc_refcounted::<union_Op>();
unsafe {
let ptr = roc_std::roc_alloc_refcounted::<union_Op>();
*ptr = union_Op {
StdoutWrite: core::mem::ManuallyDrop::new(arg),
};
*ptr = union_Op {
StdoutWrite: core::mem::ManuallyDrop::new(arg)
};
Self {
pointer: Self::tag_discriminant(ptr, discriminant_Op::StdoutWrite),
Self {
pointer: Self::tag_discriminant(ptr, discriminant_Op::StdoutWrite),
}
}
}
}
#[cfg(any(target_arch = "arm", target_arch = "wasm32", target_arch = "x86"))]
#[cfg(any(
target_arch = "arm",
target_arch = "wasm32",
target_arch = "x86"
))]
/// Unsafely assume this `Op` has a `.discriminant()` of `StdoutWrite` and convert it to `StdoutWrite`'s payload.
/// (Always examine `.discriminant()` first to make sure this is the correct variant!)
/// Panics in debug builds if the `.discriminant()` doesn't return `StdoutWrite`.
pub unsafe fn into_StdoutWrite(mut self) -> Op_StdoutWrite {
debug_assert_eq!(self.discriminant(), discriminant_Op::StdoutWrite);
/// (Always examine `.discriminant()` first to make sure this is the correct variant!)
/// Panics in debug builds if the `.discriminant()` doesn't return `StdoutWrite`.
pub unsafe fn into_StdoutWrite(mut self) -> Op_StdoutWrite {
debug_assert_eq!(self.discriminant(), discriminant_Op::StdoutWrite);
let payload = {
let ptr = (self.pointer as usize & !0b11) as *mut union_Op;
let mut uninitialized = core::mem::MaybeUninit::uninit();
@ -413,12 +440,16 @@ impl Op {
payload
}
#[cfg(any(target_arch = "arm", target_arch = "wasm32", target_arch = "x86"))]
#[cfg(any(
target_arch = "arm",
target_arch = "wasm32",
target_arch = "x86"
))]
/// Unsafely assume this `Op` has a `.discriminant()` of `StdoutWrite` and return its payload.
/// (Always examine `.discriminant()` first to make sure this is the correct variant!)
/// Panics in debug builds if the `.discriminant()` doesn't return `StdoutWrite`.
pub unsafe fn as_StdoutWrite(&self) -> &Op_StdoutWrite {
debug_assert_eq!(self.discriminant(), discriminant_Op::StdoutWrite);
/// (Always examine `.discriminant()` first to make sure this is the correct variant!)
/// Panics in debug builds if the `.discriminant()` doesn't return `StdoutWrite`.
pub unsafe fn as_StdoutWrite(&self) -> &Op_StdoutWrite {
debug_assert_eq!(self.discriminant(), discriminant_Op::StdoutWrite);
let payload = {
let ptr = (self.pointer as usize & !0b11) as *mut union_Op;
@ -428,14 +459,20 @@ impl Op {
&payload
}
#[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))]
#[cfg(any(
target_arch = "aarch64",
target_arch = "x86_64"
))]
/// Returns which variant this tag union holds. Note that this never includes a payload!
pub fn discriminant(&self) -> discriminant_Op {
// The discriminant is stored in the unused bytes at the end of the recursive pointer
unsafe { core::mem::transmute::<u8, discriminant_Op>((self.pointer as u8) & 0b111) }
}
#[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))]
#[cfg(any(
target_arch = "aarch64",
target_arch = "x86_64"
))]
/// Internal helper
fn tag_discriminant(pointer: *mut union_Op, discriminant: discriminant_Op) -> *mut union_Op {
// The discriminant is stored in the unused bytes at the end of the union pointer
@ -445,19 +482,25 @@ impl Op {
tagged as *mut union_Op
}
#[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))]
#[cfg(any(
target_arch = "aarch64",
target_arch = "x86_64"
))]
/// Internal helper
fn union_pointer(&self) -> *mut union_Op {
// The discriminant is stored in the unused bytes at the end of the union pointer
((self.pointer as usize) & (!0b111 as usize)) as *mut union_Op
}
#[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))]
#[cfg(any(
target_arch = "aarch64",
target_arch = "x86_64"
))]
/// Unsafely assume this `Op` has a `.discriminant()` of `StderrWrite` and convert it to `StderrWrite`'s payload.
/// (Always examine `.discriminant()` first to make sure this is the correct variant!)
/// Panics in debug builds if the `.discriminant()` doesn't return `StderrWrite`.
pub unsafe fn into_StderrWrite(mut self) -> Op_StderrWrite {
debug_assert_eq!(self.discriminant(), discriminant_Op::StderrWrite);
/// (Always examine `.discriminant()` first to make sure this is the correct variant!)
/// Panics in debug builds if the `.discriminant()` doesn't return `StderrWrite`.
pub unsafe fn into_StderrWrite(mut self) -> Op_StderrWrite {
debug_assert_eq!(self.discriminant(), discriminant_Op::StderrWrite);
let payload = {
let ptr = (self.pointer as usize & !0b111) as *mut union_Op;
let mut uninitialized = core::mem::MaybeUninit::uninit();
@ -476,12 +519,15 @@ impl Op {
payload
}
#[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))]
#[cfg(any(
target_arch = "aarch64",
target_arch = "x86_64"
))]
/// Unsafely assume this `Op` has a `.discriminant()` of `StderrWrite` and return its payload.
/// (Always examine `.discriminant()` first to make sure this is the correct variant!)
/// Panics in debug builds if the `.discriminant()` doesn't return `StderrWrite`.
pub unsafe fn as_StderrWrite(&self) -> &Op_StderrWrite {
debug_assert_eq!(self.discriminant(), discriminant_Op::StderrWrite);
/// (Always examine `.discriminant()` first to make sure this is the correct variant!)
/// Panics in debug builds if the `.discriminant()` doesn't return `StderrWrite`.
pub unsafe fn as_StderrWrite(&self) -> &Op_StderrWrite {
debug_assert_eq!(self.discriminant(), discriminant_Op::StderrWrite);
let payload = {
let ptr = (self.pointer as usize & !0b111) as *mut union_Op;
@ -491,12 +537,15 @@ impl Op {
&payload
}
#[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))]
#[cfg(any(
target_arch = "aarch64",
target_arch = "x86_64"
))]
/// Unsafely assume this `Op` has a `.discriminant()` of `StdoutWrite` and convert it to `StdoutWrite`'s payload.
/// (Always examine `.discriminant()` first to make sure this is the correct variant!)
/// Panics in debug builds if the `.discriminant()` doesn't return `StdoutWrite`.
pub unsafe fn into_StdoutWrite(mut self) -> Op_StdoutWrite {
debug_assert_eq!(self.discriminant(), discriminant_Op::StdoutWrite);
/// (Always examine `.discriminant()` first to make sure this is the correct variant!)
/// Panics in debug builds if the `.discriminant()` doesn't return `StdoutWrite`.
pub unsafe fn into_StdoutWrite(mut self) -> Op_StdoutWrite {
debug_assert_eq!(self.discriminant(), discriminant_Op::StdoutWrite);
let payload = {
let ptr = (self.pointer as usize & !0b111) as *mut union_Op;
let mut uninitialized = core::mem::MaybeUninit::uninit();
@ -515,12 +564,15 @@ impl Op {
payload
}
#[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))]
#[cfg(any(
target_arch = "aarch64",
target_arch = "x86_64"
))]
/// Unsafely assume this `Op` has a `.discriminant()` of `StdoutWrite` and return its payload.
/// (Always examine `.discriminant()` first to make sure this is the correct variant!)
/// Panics in debug builds if the `.discriminant()` doesn't return `StdoutWrite`.
pub unsafe fn as_StdoutWrite(&self) -> &Op_StdoutWrite {
debug_assert_eq!(self.discriminant(), discriminant_Op::StdoutWrite);
/// (Always examine `.discriminant()` first to make sure this is the correct variant!)
/// Panics in debug builds if the `.discriminant()` doesn't return `StdoutWrite`.
pub unsafe fn as_StdoutWrite(&self) -> &Op_StdoutWrite {
debug_assert_eq!(self.discriminant(), discriminant_Op::StdoutWrite);
let payload = {
let ptr = (self.pointer as usize & !0b111) as *mut union_Op;
@ -549,23 +601,17 @@ impl Drop for Op {
if needs_dealloc {
// Drop the payload first.
match self.discriminant() {
discriminant_Op::Done => {}
discriminant_Op::StderrWrite => unsafe {
core::mem::ManuallyDrop::drop(&mut (&mut *self.union_pointer()).StderrWrite)
},
discriminant_Op::StdoutWrite => unsafe {
core::mem::ManuallyDrop::drop(&mut (&mut *self.union_pointer()).StdoutWrite)
},
}
match self.discriminant() {
discriminant_Op::Done => {}
discriminant_Op::StderrWrite => unsafe { core::mem::ManuallyDrop::drop(&mut (&mut *self.union_pointer()).StderrWrite) },
discriminant_Op::StdoutWrite => unsafe { core::mem::ManuallyDrop::drop(&mut (&mut *self.union_pointer()).StdoutWrite) },
}
// Dealloc the pointer
let alignment =
core::mem::align_of::<Self>().max(core::mem::align_of::<roc_std::Storage>());
let alignment = core::mem::align_of::<Self>().max(core::mem::align_of::<roc_std::Storage>());
unsafe {
crate::roc_dealloc(storage.as_ptr().cast(), alignment as u32);
}
unsafe { crate::roc_dealloc(storage.as_ptr().cast(), alignment as u32); }
} else {
// Write the storage back.
storage.set(new_storage);
@ -585,19 +631,15 @@ impl PartialEq for Op {
target_arch = "x86_64"
))]
fn eq(&self, other: &Self) -> bool {
if self.discriminant() != other.discriminant() {
return false;
}
if self.discriminant() != other.discriminant() {
return false;
}
unsafe {
unsafe {
match self.discriminant() {
discriminant_Op::Done => true,
discriminant_Op::StderrWrite => {
(&*self.union_pointer()).StderrWrite == (&*other.union_pointer()).StderrWrite
}
discriminant_Op::StdoutWrite => {
(&*self.union_pointer()).StdoutWrite == (&*other.union_pointer()).StdoutWrite
}
discriminant_Op::StderrWrite => (&*self.union_pointer()).StderrWrite == (&*other.union_pointer()).StderrWrite,
discriminant_Op::StdoutWrite => (&*self.union_pointer()).StdoutWrite == (&*other.union_pointer()).StdoutWrite,
}
}
}
@ -620,12 +662,8 @@ impl PartialOrd for Op {
unsafe {
match self.discriminant() {
discriminant_Op::Done => Some(core::cmp::Ordering::Equal),
discriminant_Op::StderrWrite => (&*self.union_pointer())
.StderrWrite
.partial_cmp(&(&*other.union_pointer()).StderrWrite),
discriminant_Op::StdoutWrite => (&*self.union_pointer())
.StdoutWrite
.partial_cmp(&(&*other.union_pointer()).StdoutWrite),
discriminant_Op::StderrWrite => (&*self.union_pointer()).StderrWrite.partial_cmp(&(&*other.union_pointer()).StderrWrite),
discriminant_Op::StdoutWrite => (&*self.union_pointer()).StdoutWrite.partial_cmp(&(&*other.union_pointer()).StdoutWrite),
}
}
}
@ -640,20 +678,16 @@ impl Ord for Op {
target_arch = "x86_64"
))]
fn cmp(&self, other: &Self) -> core::cmp::Ordering {
match self.discriminant().cmp(&other.discriminant()) {
core::cmp::Ordering::Equal => {}
not_eq => return not_eq,
}
match self.discriminant().cmp(&other.discriminant()) {
core::cmp::Ordering::Equal => {}
not_eq => return not_eq,
}
unsafe {
unsafe {
match self.discriminant() {
discriminant_Op::Done => core::cmp::Ordering::Equal,
discriminant_Op::StderrWrite => (&*self.union_pointer())
.StderrWrite
.cmp(&(&*other.union_pointer()).StderrWrite),
discriminant_Op::StdoutWrite => (&*self.union_pointer())
.StdoutWrite
.cmp(&(&*other.union_pointer()).StdoutWrite),
discriminant_Op::StderrWrite => (&*self.union_pointer()).StderrWrite.cmp(&(&*other.union_pointer()).StderrWrite),
discriminant_Op::StdoutWrite => (&*self.union_pointer()).StdoutWrite.cmp(&(&*other.union_pointer()).StdoutWrite),
}
}
}
@ -677,7 +711,7 @@ impl Clone for Op {
}
Self {
pointer: self.pointer,
pointer: self.pointer
}
}
}
@ -690,17 +724,16 @@ impl core::hash::Hash for Op {
target_arch = "x86",
target_arch = "x86_64"
))]
fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
match self.discriminant() {
fn hash<H: core::hash::Hasher>(&self, state: &mut H) { match self.discriminant() {
discriminant_Op::Done => discriminant_Op::Done.hash(state),
discriminant_Op::StderrWrite => unsafe {
discriminant_Op::StderrWrite.hash(state);
(&*self.union_pointer()).StderrWrite.hash(state);
},
discriminant_Op::StderrWrite.hash(state);
(&*self.union_pointer()).StderrWrite.hash(state);
},
discriminant_Op::StdoutWrite => unsafe {
discriminant_Op::StdoutWrite.hash(state);
(&*self.union_pointer()).StdoutWrite.hash(state);
},
discriminant_Op::StdoutWrite.hash(state);
(&*self.union_pointer()).StdoutWrite.hash(state);
},
}
}
}
@ -719,14 +752,12 @@ impl core::fmt::Debug for Op {
unsafe {
match self.discriminant() {
discriminant_Op::Done => f.write_str("Done"),
discriminant_Op::StderrWrite => f
.debug_tuple("StderrWrite")
// TODO HAS CLOSURE
.finish(),
discriminant_Op::StdoutWrite => f
.debug_tuple("StdoutWrite")
// TODO HAS CLOSURE
.finish(),
discriminant_Op::StderrWrite => f.debug_tuple("StderrWrite")
// TODO HAS CLOSURE
.finish(),
discriminant_Op::StdoutWrite => f.debug_tuple("StdoutWrite")
// TODO HAS CLOSURE
.finish(),
}
}
}