Exemplo n.º 1
0
        private static MethodSpec GetVirtualMethod(TypeSpec impl_ts, MethodSpec decl_ms,
                                                   target.Target t, bool allow_non_virtual = false)
        {
            /* Iterate through methods looking for virtual ones */
            var first_mdef = impl_ts.m.GetIntEntry(MetadataStream.tid_TypeDef,
                                                   impl_ts.tdrow, 5);
            var last_mdef = impl_ts.m.GetLastMethodDef(impl_ts.tdrow);

            for (uint mdef_row = first_mdef; mdef_row < last_mdef; mdef_row++)
            {
                var flags = impl_ts.m.GetIntEntry(MetadataStream.tid_MethodDef,
                                                  (int)mdef_row, 2);

                if (allow_non_virtual || (flags & 0x40) == 0x40)
                {
                    MethodSpec impl_ms;
                    impl_ts.m.GetMethodDefRow(MetadataStream.tid_MethodDef,
                                              (int)mdef_row, out impl_ms, impl_ts.gtparams, null);
                    impl_ms.type = impl_ts;

                    if ((flags & 0x400) != 0x400)
                    {
                        // Not marked abstract
                        if (MetadataStream.CompareString(impl_ms.m,
                                                         impl_ms.m.GetIntEntry(MetadataStream.tid_MethodDef, (int)mdef_row, 3),
                                                         decl_ms.m,
                                                         decl_ms.m.GetIntEntry(MetadataStream.tid_MethodDef, (int)decl_ms.mdrow, 3)))
                        {
                            if (MetadataStream.CompareSignature(impl_ms.m, impl_ms.msig,
                                                                impl_ts.gtparams, null,
                                                                decl_ms.m, decl_ms.msig, impl_ts.gtparams, null))
                            {
                                // this is the correct one
                                return(impl_ms);
                            }
                            if (MetadataStream.CompareSignature(impl_ms.m, impl_ms.msig,
                                                                impl_ts.gtparams, null,
                                                                decl_ms.m, decl_ms.msig, decl_ms.gtparams, null))
                            {
                                // this is the correct one
                                return(impl_ms);
                            }
                        }
                    }
                }
            }

            // if not found, look to base classes
            var bc = impl_ts.GetExtends();

            if (bc != null)
            {
                return(GetVirtualMethod(bc, decl_ms, t, allow_non_virtual));
            }
            else
            {
                return(null);
            }
        }
Exemplo n.º 2
0
 private static int GetVTableIndex(MethodSpec ms, List <VTableItem> list)
 {
     for (int idx = 0; idx < list.Count; idx++)
     {
         var i = list[idx];
         if (MetadataStream.CompareString(ms.m, ms.m.GetIntEntry(MetadataStream.tid_MethodDef, ms.mdrow, 3),
                                          i.unimpl_meth.m, i.unimpl_meth.m.GetIntEntry(MetadataStream.tid_MethodDef, i.unimpl_meth.mdrow, 3)))
         {
             if (MetadataStream.CompareSignature(ms, i.unimpl_meth))
             {
                 return(idx);
             }
         }
     }
     return(-1);
 }
Exemplo n.º 3
0
        public static int GetVTableOffset(metadata.TypeSpec ts,
                                          metadata.MethodSpec ms, Target t)
        {
            var vtbl             = GetVirtualMethodDeclarations(ts);
            var search_meth_name = ms.m.GetIntEntry(MetadataStream.tid_MethodDef,
                                                    ms.mdrow, 3);

            // find the requested method, match on name, signature and declaring type
            for (int i = 0; i < vtbl.Count; i++)
            {
                var test  = vtbl[i];
                var mdecl = test.unimpl_meth;
                if (mdecl.type.Equals(ts))
                {
                    // Check on name
                    var mname = mdecl.m.GetIntEntry(MetadataStream.tid_MethodDef,
                                                    mdecl.mdrow, 3);
                    if (MetadataStream.CompareString(mdecl.m, mname,
                                                     ms.m, search_meth_name))
                    {
                        // Check on signature
                        if (MetadataStream.CompareSignature(mdecl.m, mdecl.msig,
                                                            mdecl.gtparams, mdecl.gmparams,
                                                            ms.m, ms.msig, ms.gtparams, ms.gmparams))
                        {
                            if (ts.IsInterface == false)
                            {
                                i += (6 + t.ExtraVTableFieldsPointerLength);
                            }
                            return(i);
                        }
                    }
                }
            }

            throw new Exception("Requested virtual method slot not found");
        }
Exemplo n.º 4
0
        public static void ImplementVirtualMethods(TypeSpec ts, List <VTableItem> list)
        {
            // We implement those methods in the most derived class first and work back
            foreach (var i in list)
            {
                // skip if already done
                if (i.impl_meth != null)
                {
                    continue;
                }

                // if we've gone back far enough to the max_implementor class
                //  we can start looking for implementations from here
                if (i.max_implementor != null && i.max_implementor.Equals(ts))
                {
                    i.max_implementor = null;
                }

                // if we haven't, skip this method for this class (it will be
                //  implemented in a base class)
                if (i.max_implementor != null)
                {
                    continue;
                }

                // Now, search for a matching method in this particular class
                /* Iterate through methods looking for virtual ones */
                var first_mdef = ts.m.GetIntEntry(MetadataStream.tid_TypeDef,
                                                  ts.tdrow, 5);
                var last_mdef        = ts.m.GetLastMethodDef(ts.tdrow);
                var search_meth_name = i.unimpl_meth.m.GetIntEntry(MetadataStream.tid_MethodDef,
                                                                   i.unimpl_meth.mdrow, 3);

                for (uint mdef_row = first_mdef; mdef_row < last_mdef; mdef_row++)
                {
                    var flags = ts.m.GetIntEntry(MetadataStream.tid_MethodDef,
                                                 (int)mdef_row, 2);

                    if ((flags & 0x40) == 0x40)
                    {
                        // its a virtual method
                        MethodSpec impl_ms;
                        ts.m.GetMethodDefRow(MetadataStream.tid_MethodDef,
                                             (int)mdef_row, out impl_ms, ts.gtparams, null);
                        impl_ms.type = ts;

                        // compare on name
                        if (MetadataStream.CompareString(i.unimpl_meth.m, search_meth_name,
                                                         ts.m, ts.m.GetIntEntry(MetadataStream.tid_MethodDef, (int)mdef_row, 3)))
                        {
                            // and on signature
                            if (MetadataStream.CompareSignature(i.unimpl_meth, impl_ms))
                            {
                                // If its marked abstract, we dont implement it
                                if ((flags & 0x400) == 0x400)
                                {
                                    i.impl_meth = null;
                                }
                                else
                                {
                                    // we have found a valid implementing method
                                    i.impl_meth = impl_ms;
                                }
                            }
                        }
                    }
                }
            }

            // now implement on base classes
            var extends = ts.GetExtends();

            if (extends != null)
            {
                ImplementVirtualMethods(extends, list);
            }
        }