Interface dispatch support

[nattress]

Emit the supporting data structures for interface dispatch:

• Interface dispatch cell for each call site providing the resolution function entry point as well as the interface type and interface method slot number
• Interface map on EETypes specifying the list of interfaces they implement
• Dispatch map that provides, for each type, the lookup rows for interface type, interface method slot, and implementing method's VTable slot
• Dispatch map table that provides dispatch map pointers (the index into this table is stored on an EEType instead of a pointer to the map for space savings)

Added a work-around in the runtime to provide access to the dispatch map table until full module headers are implemented

[nattress]

@jkotas@davidwrighton@smosier Please take a look. David, I removed a couple type system asserts in TypeSystemContext::GetMethodForInstantiatedType. For interface method impls, they had instantiations in my testing and removing the asserts seemed to work fine :)

Scott: I added you to make sure you're okay with my temporary workaround for no ModuleHeader support. I plumbed the dispatch map table in via a RuntimeInstance helper.

[jkotas]

I would keep the Program.cs in repro as is. Instead, we should add a new smoke test under tests\src\simple that has what you got here.

[jkotas]

For Unix, could you please just fix the build breaks (e.g. by adding dummy methods to portable.cpp)? We can deal with porting the assembly code in separate change.

[jkotas]

LGTM otherwise

[MichalStrehovsky]

Nit: can you do a sweep of all the whitespace you're checking in?

[nattress]

@jkotas@MichalStrehovsky@davidwrighton Updated based on your feedback.

Also, I split TypeDesc.MethodImpls.cs into two (based on the type names stored in it): MetadataType.MethodImpls.cs, InstantiatedType.MethodImpls.cs

I added a stub .S for the cross-plat assembly code needed for dispatch. Portable.cpp should already have the missing entry points (we'll see when CI finishes).

[manu-st]

@nattress Could you add stub for Linux arm and arm64 as well?

[jkotas]

split TypeDesc.MethodImpls.cs into two (based on the type names stored in it)

The split files need to be in the common directory - you have added them to the compiler directory.

We have been going back and forth on whether the files should be split for cases like this or not. I believe that we have been leaning towards keeping them together. Splitting these into multiple files rigorously leads to way too many little files.

[jkotas]

This needs @TODO: CORERT: Use ManagedCallout2.

[MichalStrehovsky]

Interfaces are allowed to have static methods. Might need to skip them here.

[MichalStrehovsky]

Instead of asserting the method is virtual, we should probably throw (unless this is guarded in some other place).

[nattress]

Emit the supporting data structures for interface dispatch:

• Interface dispatch cell for each call site providing the resolution function entry point as well as the interface type and interface method slot number
• Interface map on EETypes specifying the list of interfaces they implement
• Dispatch map that provides, for each type, the lookup rows for interface type, interface method slot, and implementing method's VTable slot
• Dispatch map table that provides dispatch map pointers (the index into this table is stored on an EEType instead of a pointer to the map for space savings)

Added a work-around in the runtime to provide access to the dispatch map table until full module headers are implemented

[nattress]

@jkotas@davidwrighton@smosier Please take a look. David, I removed a couple type system asserts in TypeSystemContext::GetMethodForInstantiatedType. For interface method impls, they had instantiations in my testing and removing the asserts seemed to work fine :)

Scott: I added you to make sure you're okay with my temporary workaround for no ModuleHeader support. I plumbed the dispatch map table in via a RuntimeInstance helper.

[jkotas]

I would keep the Program.cs in repro as is. Instead, we should add a new smoke test under tests\src\simple that has what you got here.

[jkotas]

For Unix, could you please just fix the build breaks (e.g. by adding dummy methods to portable.cpp)? We can deal with porting the assembly code in separate change.

[jkotas]

LGTM otherwise

[MichalStrehovsky]

Nit: can you do a sweep of all the whitespace you're checking in?

[nattress]

@jkotas@MichalStrehovsky@davidwrighton Updated based on your feedback.

Also, I split TypeDesc.MethodImpls.cs into two (based on the type names stored in it): MetadataType.MethodImpls.cs, InstantiatedType.MethodImpls.cs

I added a stub .S for the cross-plat assembly code needed for dispatch. Portable.cpp should already have the missing entry points (we'll see when CI finishes).

[manu-st]

@nattress Could you add stub for Linux arm and arm64 as well?

[jkotas]

split TypeDesc.MethodImpls.cs into two (based on the type names stored in it)

The split files need to be in the common directory - you have added them to the compiler directory.

We have been going back and forth on whether the files should be split for cases like this or not. I believe that we have been leaning towards keeping them together. Splitting these into multiple files rigorously leads to way too many little files.

[jkotas]

This needs @TODO: CORERT: Use ManagedCallout2.

[MichalStrehovsky]

Interfaces are allowed to have static methods. Might need to skip them here.

[MichalStrehovsky]

Instead of asserting the method is virtual, we should probably throw (unless this is guarded in some other place).

[nattress]

Emit the supporting data structures for interface dispatch:

• Interface dispatch cell for each call site providing the resolution function entry point as well as the interface type and interface method slot number
• Interface map on EETypes specifying the list of interfaces they implement
• Dispatch map that provides, for each type, the lookup rows for interface type, interface method slot, and implementing method's VTable slot
• Dispatch map table that provides dispatch map pointers (the index into this table is stored on an EEType instead of a pointer to the map for space savings)

Added a work-around in the runtime to provide access to the dispatch map table until full module headers are implemented

[nattress]

@jkotas@davidwrighton@smosier Please take a look. David, I removed a couple type system asserts in TypeSystemContext::GetMethodForInstantiatedType. For interface method impls, they had instantiations in my testing and removing the asserts seemed to work fine :)

Scott: I added you to make sure you're okay with my temporary workaround for no ModuleHeader support. I plumbed the dispatch map table in via a RuntimeInstance helper.

[jkotas]

I would keep the Program.cs in repro as is. Instead, we should add a new smoke test under tests\src\simple that has what you got here.

[jkotas]

For Unix, could you please just fix the build breaks (e.g. by adding dummy methods to portable.cpp)? We can deal with porting the assembly code in separate change.

[jkotas]

LGTM otherwise

[MichalStrehovsky]

Nit: can you do a sweep of all the whitespace you're checking in?

[nattress]

@jkotas@MichalStrehovsky@davidwrighton Updated based on your feedback.

Also, I split TypeDesc.MethodImpls.cs into two (based on the type names stored in it): MetadataType.MethodImpls.cs, InstantiatedType.MethodImpls.cs

I added a stub .S for the cross-plat assembly code needed for dispatch. Portable.cpp should already have the missing entry points (we'll see when CI finishes).

[manu-st]

@nattress Could you add stub for Linux arm and arm64 as well?

[jkotas]

split TypeDesc.MethodImpls.cs into two (based on the type names stored in it)

The split files need to be in the common directory - you have added them to the compiler directory.

We have been going back and forth on whether the files should be split for cases like this or not. I believe that we have been leaning towards keeping them together. Splitting these into multiple files rigorously leads to way too many little files.

[jkotas]

This needs @TODO: CORERT: Use ManagedCallout2.

[MichalStrehovsky]

Interfaces are allowed to have static methods. Might need to skip them here.

[MichalStrehovsky]

Instead of asserting the method is virtual, we should probably throw (unless this is guarded in some other place).

[nattress]

Emit the supporting data structures for interface dispatch:

• Interface dispatch cell for each call site providing the resolution function entry point as well as the interface type and interface method slot number
• Interface map on EETypes specifying the list of interfaces they implement
• Dispatch map that provides, for each type, the lookup rows for interface type, interface method slot, and implementing method's VTable slot
• Dispatch map table that provides dispatch map pointers (the index into this table is stored on an EEType instead of a pointer to the map for space savings)

Added a work-around in the runtime to provide access to the dispatch map table until full module headers are implemented

[nattress]

@jkotas@davidwrighton@smosier Please take a look. David, I removed a couple type system asserts in TypeSystemContext::GetMethodForInstantiatedType. For interface method impls, they had instantiations in my testing and removing the asserts seemed to work fine :)

Scott: I added you to make sure you're okay with my temporary workaround for no ModuleHeader support. I plumbed the dispatch map table in via a RuntimeInstance helper.

[jkotas]

I would keep the Program.cs in repro as is. Instead, we should add a new smoke test under tests\src\simple that has what you got here.

[jkotas]

For Unix, could you please just fix the build breaks (e.g. by adding dummy methods to portable.cpp)? We can deal with porting the assembly code in separate change.

[jkotas]

LGTM otherwise

[MichalStrehovsky]

Nit: can you do a sweep of all the whitespace you're checking in?

[nattress]

@jkotas@MichalStrehovsky@davidwrighton Updated based on your feedback.

Also, I split TypeDesc.MethodImpls.cs into two (based on the type names stored in it): MetadataType.MethodImpls.cs, InstantiatedType.MethodImpls.cs

I added a stub .S for the cross-plat assembly code needed for dispatch. Portable.cpp should already have the missing entry points (we'll see when CI finishes).

[manu-st]

@nattress Could you add stub for Linux arm and arm64 as well?

[jkotas]

split TypeDesc.MethodImpls.cs into two (based on the type names stored in it)

The split files need to be in the common directory - you have added them to the compiler directory.

We have been going back and forth on whether the files should be split for cases like this or not. I believe that we have been leaning towards keeping them together. Splitting these into multiple files rigorously leads to way too many little files.

[jkotas]

This needs @TODO: CORERT: Use ManagedCallout2.

[MichalStrehovsky]

Interfaces are allowed to have static methods. Might need to skip them here.

[MichalStrehovsky]

Instead of asserting the method is virtual, we should probably throw (unless this is guarded in some other place).

[nattress]

Emit the supporting data structures for interface dispatch:

• Interface dispatch cell for each call site providing the resolution function entry point as well as the interface type and interface method slot number
• Interface map on EETypes specifying the list of interfaces they implement
• Dispatch map that provides, for each type, the lookup rows for interface type, interface method slot, and implementing method's VTable slot
• Dispatch map table that provides dispatch map pointers (the index into this table is stored on an EEType instead of a pointer to the map for space savings)

Added a work-around in the runtime to provide access to the dispatch map table until full module headers are implemented

[nattress]

@jkotas@davidwrighton@smosier Please take a look. David, I removed a couple type system asserts in TypeSystemContext::GetMethodForInstantiatedType. For interface method impls, they had instantiations in my testing and removing the asserts seemed to work fine :)

Scott: I added you to make sure you're okay with my temporary workaround for no ModuleHeader support. I plumbed the dispatch map table in via a RuntimeInstance helper.

[jkotas]

I would keep the Program.cs in repro as is. Instead, we should add a new smoke test under tests\src\simple that has what you got here.

[jkotas]

For Unix, could you please just fix the build breaks (e.g. by adding dummy methods to portable.cpp)? We can deal with porting the assembly code in separate change.

[jkotas]

LGTM otherwise

[MichalStrehovsky]

Nit: can you do a sweep of all the whitespace you're checking in?

[nattress]

@jkotas@MichalStrehovsky@davidwrighton Updated based on your feedback.

Also, I split TypeDesc.MethodImpls.cs into two (based on the type names stored in it): MetadataType.MethodImpls.cs, InstantiatedType.MethodImpls.cs

I added a stub .S for the cross-plat assembly code needed for dispatch. Portable.cpp should already have the missing entry points (we'll see when CI finishes).

[manu-st]

@nattress Could you add stub for Linux arm and arm64 as well?

[jkotas]

split TypeDesc.MethodImpls.cs into two (based on the type names stored in it)

The split files need to be in the common directory - you have added them to the compiler directory.

We have been going back and forth on whether the files should be split for cases like this or not. I believe that we have been leaning towards keeping them together. Splitting these into multiple files rigorously leads to way too many little files.

[jkotas]

This needs @TODO: CORERT: Use ManagedCallout2.

[MichalStrehovsky]

Interfaces are allowed to have static methods. Might need to skip them here.

[MichalStrehovsky]

Instead of asserting the method is virtual, we should probably throw (unless this is guarded in some other place).

[nattress]

Emit the supporting data structures for interface dispatch:

• Interface dispatch cell for each call site providing the resolution function entry point as well as the interface type and interface method slot number
• Interface map on EETypes specifying the list of interfaces they implement
• Dispatch map that provides, for each type, the lookup rows for interface type, interface method slot, and implementing method's VTable slot
• Dispatch map table that provides dispatch map pointers (the index into this table is stored on an EEType instead of a pointer to the map for space savings)

Added a work-around in the runtime to provide access to the dispatch map table until full module headers are implemented

[nattress]

@jkotas@davidwrighton@smosier Please take a look. David, I removed a couple type system asserts in TypeSystemContext::GetMethodForInstantiatedType. For interface method impls, they had instantiations in my testing and removing the asserts seemed to work fine :)

Scott: I added you to make sure you're okay with my temporary workaround for no ModuleHeader support. I plumbed the dispatch map table in via a RuntimeInstance helper.

[jkotas]

I would keep the Program.cs in repro as is. Instead, we should add a new smoke test under tests\src\simple that has what you got here.

[jkotas]

For Unix, could you please just fix the build breaks (e.g. by adding dummy methods to portable.cpp)? We can deal with porting the assembly code in separate change.

[jkotas]

LGTM otherwise

[MichalStrehovsky]

Nit: can you do a sweep of all the whitespace you're checking in?

[nattress]

@jkotas@MichalStrehovsky@davidwrighton Updated based on your feedback.

Also, I split TypeDesc.MethodImpls.cs into two (based on the type names stored in it): MetadataType.MethodImpls.cs, InstantiatedType.MethodImpls.cs

I added a stub .S for the cross-plat assembly code needed for dispatch. Portable.cpp should already have the missing entry points (we'll see when CI finishes).

[manu-st]

@nattress Could you add stub for Linux arm and arm64 as well?

[jkotas]

split TypeDesc.MethodImpls.cs into two (based on the type names stored in it)

The split files need to be in the common directory - you have added them to the compiler directory.

We have been going back and forth on whether the files should be split for cases like this or not. I believe that we have been leaning towards keeping them together. Splitting these into multiple files rigorously leads to way too many little files.

[jkotas]

This needs @TODO: CORERT: Use ManagedCallout2.

[MichalStrehovsky]

Interfaces are allowed to have static methods. Might need to skip them here.

[MichalStrehovsky]

Instead of asserting the method is virtual, we should probably throw (unless this is guarded in some other place).

[nattress]

Emit the supporting data structures for interface dispatch:

• Interface dispatch cell for each call site providing the resolution function entry point as well as the interface type and interface method slot number
• Interface map on EETypes specifying the list of interfaces they implement
• Dispatch map that provides, for each type, the lookup rows for interface type, interface method slot, and implementing method's VTable slot
• Dispatch map table that provides dispatch map pointers (the index into this table is stored on an EEType instead of a pointer to the map for space savings)

Added a work-around in the runtime to provide access to the dispatch map table until full module headers are implemented

[nattress]

@jkotas@davidwrighton@smosier Please take a look. David, I removed a couple type system asserts in TypeSystemContext::GetMethodForInstantiatedType. For interface method impls, they had instantiations in my testing and removing the asserts seemed to work fine :)

Scott: I added you to make sure you're okay with my temporary workaround for no ModuleHeader support. I plumbed the dispatch map table in via a RuntimeInstance helper.

[jkotas]

I would keep the Program.cs in repro as is. Instead, we should add a new smoke test under tests\src\simple that has what you got here.

[jkotas]

For Unix, could you please just fix the build breaks (e.g. by adding dummy methods to portable.cpp)? We can deal with porting the assembly code in separate change.

[jkotas]

LGTM otherwise

[MichalStrehovsky]

Nit: can you do a sweep of all the whitespace you're checking in?

[nattress]

@jkotas@MichalStrehovsky@davidwrighton Updated based on your feedback.

Also, I split TypeDesc.MethodImpls.cs into two (based on the type names stored in it): MetadataType.MethodImpls.cs, InstantiatedType.MethodImpls.cs

I added a stub .S for the cross-plat assembly code needed for dispatch. Portable.cpp should already have the missing entry points (we'll see when CI finishes).

[manu-st]

@nattress Could you add stub for Linux arm and arm64 as well?

[jkotas]

split TypeDesc.MethodImpls.cs into two (based on the type names stored in it)

The split files need to be in the common directory - you have added them to the compiler directory.

We have been going back and forth on whether the files should be split for cases like this or not. I believe that we have been leaning towards keeping them together. Splitting these into multiple files rigorously leads to way too many little files.

[jkotas]

This needs @TODO: CORERT: Use ManagedCallout2.

[MichalStrehovsky]

Interfaces are allowed to have static methods. Might need to skip them here.

[MichalStrehovsky]

Instead of asserting the method is virtual, we should probably throw (unless this is guarded in some other place).

[nattress]

Emit the supporting data structures for interface dispatch:

• Interface dispatch cell for each call site providing the resolution function entry point as well as the interface type and interface method slot number
• Interface map on EETypes specifying the list of interfaces they implement
• Dispatch map that provides, for each type, the lookup rows for interface type, interface method slot, and implementing method's VTable slot
• Dispatch map table that provides dispatch map pointers (the index into this table is stored on an EEType instead of a pointer to the map for space savings)

Added a work-around in the runtime to provide access to the dispatch map table until full module headers are implemented

[nattress]

@jkotas@davidwrighton@smosier Please take a look. David, I removed a couple type system asserts in TypeSystemContext::GetMethodForInstantiatedType. For interface method impls, they had instantiations in my testing and removing the asserts seemed to work fine :)

Scott: I added you to make sure you're okay with my temporary workaround for no ModuleHeader support. I plumbed the dispatch map table in via a RuntimeInstance helper.

[jkotas]

I would keep the Program.cs in repro as is. Instead, we should add a new smoke test under tests\src\simple that has what you got here.

[jkotas]

For Unix, could you please just fix the build breaks (e.g. by adding dummy methods to portable.cpp)? We can deal with porting the assembly code in separate change.

[jkotas]

LGTM otherwise

[MichalStrehovsky]

Nit: can you do a sweep of all the whitespace you're checking in?

[nattress]

@jkotas@MichalStrehovsky@davidwrighton Updated based on your feedback.

Also, I split TypeDesc.MethodImpls.cs into two (based on the type names stored in it): MetadataType.MethodImpls.cs, InstantiatedType.MethodImpls.cs

I added a stub .S for the cross-plat assembly code needed for dispatch. Portable.cpp should already have the missing entry points (we'll see when CI finishes).

[manu-st]

@nattress Could you add stub for Linux arm and arm64 as well?

[jkotas]

split TypeDesc.MethodImpls.cs into two (based on the type names stored in it)

The split files need to be in the common directory - you have added them to the compiler directory.

We have been going back and forth on whether the files should be split for cases like this or not. I believe that we have been leaning towards keeping them together. Splitting these into multiple files rigorously leads to way too many little files.

[jkotas]

This needs @TODO: CORERT: Use ManagedCallout2.

[MichalStrehovsky]

Interfaces are allowed to have static methods. Might need to skip them here.

[MichalStrehovsky]

Instead of asserting the method is virtual, we should probably throw (unless this is guarded in some other place).