Back to Questions
771
views1
comment
Overlaying object references with each other in an explicitly laid out struct
f#

[b]Edit:[/b] The code highlightning crapped all over my attributes, I removed the lesser then and greater then signs, the full code (including indentation and all niceties can be found here: [link:codepad.org] )

I'm trying to explicitly overlay several object reference fields with each other in an explicitly laid out struct, and then accessing them through the correctly typed field to circumvent having to do a dynamic runtime type check.

Here is an example of what I want to do, and it actually works as expected.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

open System.Runtime.InteropServices

#nowarn "9" //Disables warning about "generation of unverifiable .NET IL code"  

[AllowNullLiteral]

type Foo() =

   class end

[AllowNullLiteral]

type Bar() =

   class end

[StructLayout(LayoutKind.Explicit)] 

type Box =

   struct

        [FieldOffset(0)] val mutable AsObject : obj

        [FieldOffset(0)] val mutable AsBar : Bar

        [FieldOffset(0)] val mutable AsFoo: Foo

   end

let mutable x = Box()

x.AsObject <- new Bar()

x.AsObject // OK

x.AsBar    // OK

x.AsFoo    // FAIL (no surprise)

// Now re-assign object reference to a Foo

x.AsObject <- new Foo()

x.AsObject // OK

x.AsFoo    // OK

x.AsBar    // FAIL (again, no surprise)

// Now re-assign to a string instead

x.AsObject <- "Hello hubfs!"

x.AsObject //OK

x.AsFoo    // FAIL (again, no surprise)

x.AsBar    // FAIL (again, no surprise)

Now my question is: Is this safe? (I tried asking on Stack Overflow, no one could give me a straight yes or no answer). And by safe I mean: Can this give me memory leaks or break the CLR in anyway as long as I only access an object from it's correctly typed field? I of course understand that if I try to access an instance of Bar through the field typed to Foo it will break (it is also demonstrated in my example code). But as long as I always access the contained object through its correct field, [b]is this safe?[/b]

.

Section 10.7 in Partition II of the ECMA 335 standard suggests that it's safe, but unverifiable:

"Offset values shall be non-negative. It is possible to overlap fields in this way, though offsets occupied by an
object reference shall not overlap with offsets occupied by a built-in value type or a part of another object
reference. While one object reference can completely overlap another, this is unverifiable."

How does your example fail on the marked lines? It doesn't for me. If you use such unverifiable code you normally can't rely on the JIT catching errors. (So it's probably a good idea to at least put some type-check asserts into your methods.)

By on 4/24/2010 7:15 AM ()

    Topic tags

    IntelliFactory Offices Copyright (c) 2011-2012 IntelliFactory. All rights reserved.
    Home | Products | Consulting | Trainings | Blogs | Jobs | Contact Us | Terms of Use | Privacy Policy | Cookie Policy     		Built with WebSharper