[Caml-list] GC assumptions ?

[Caml-list] GC assumptions ?

[Nicolas Ojeda Bar]

[-- Attachment #1: Type: text/plain, Size: 371 bytes --]

Hi list,

I am toying with the idea of using the OCaml runtime for a dynamically
typed language targeting Lambda.  I was wondering what the OCaml runtime
(ie the GC) assumes about the language being compiled.

In particular I was wondering if it assumes that a value cannot go from
pointing to a block to being an int or vice-versa.

Any ideas?

Thanks!

Cheers,
Nicolas

[-- Attachment #2: Type: text/html, Size: 524 bytes --]

Re: [Caml-list] GC assumptions ?

[Gerd Stolpmann]

[-- Attachment #1: Type: text/plain, Size: 1020 bytes --]

Am Samstag, den 16.01.2016, 22:42 +0100 schrieb Nicolas Ojeda Bar:
> Hi list,
> 
> 
> I am toying with the idea of using the OCaml runtime for a dynamically
> typed language targeting Lambda.  I was wondering what the OCaml
> runtime (ie the GC) assumes about the language being compiled.
> 
> 
> In particular I was wondering if it assumes that a value cannot go
> from pointing to a block to being an int or vice-versa.

This possibility exists in OCaml, e.g.

type t = Block of bool | Int0

Now, an assignment x := Block false; x := Int0 would do the change you
are thinking about (argument-less variants are represented as ints).

Gerd

-- 
------------------------------------------------------------
Gerd Stolpmann, Darmstadt, Germany    gerd@gerd-stolpmann.de
My OCaml site:          http://www.camlcity.org
Contact details:        http://www.camlcity.org/contact.html
Company homepage:       http://www.gerd-stolpmann.de
------------------------------------------------------------


[-- Attachment #2: This is a digitally signed message part --]
[-- Type: application/pgp-signature, Size: 473 bytes --]

Re: [Caml-list] GC assumptions ?

[Pierre Chambart]

On 17/01/2016 12:01, Gerd Stolpmann wrote:
> Am Samstag, den 16.01.2016, 22:42 +0100 schrieb Nicolas Ojeda Bar:
>> Hi list,
>>
>>
>> I am toying with the idea of using the OCaml runtime for a dynamically
>> typed language targeting Lambda.  I was wondering what the OCaml
>> runtime (ie the GC) assumes about the language being compiled.
>>
>>
>> In particular I was wondering if it assumes that a value cannot go
>> from pointing to a block to being an int or vice-versa.
> This possibility exists in OCaml, e.g.
>
> type t = Block of bool | Int0
>
> Now, an assignment x := Block false; x := Int0 would do the change you
> are thinking about (argument-less variants are represented as ints).
>
> Gerd
>
Note that in that case, the value is built as an Const_pointer instead of
an integer. It announce to the compiler that this value could contain a
block later.

But the result of integer returning primitive is assumed to always be an
integer, in particular, it is not safe to do something like: (imagine the
corresponding lambda code).

let f x =
  let r = ref (x + 1) in (* r is local mutable variable after simplify *)
  r := Obj.magic (x,x);
  call_a_function ();
  !r

Since r is considered as containing an integer, it is not registered in
the frame descriptors as a potential GC root.

This is not the only place I think that assumes that, so you should
be quite carefull.
-- 
Pierre