Unity mono代码结构分析及阅读（九）——new操作符的实现

无人岛屿颈 · 发表于 2020-12-28 10:32

这是基于unity mono代码阅读的第八篇。
上面一系列文章分析了mono CLR如何翻译CL代码到机器码，并且通过一系列示例代码演示了一些面向对象的特性在il里是如何实现的。
本文会着重分析一下mono CLR内的另外一个重量级功能，关于object new的实现，并尝试在此基础上，做一个简单Memory Profiler。
本文不涉及底层的贝姆gc的实现，如果对这块有兴趣的可以查看一下西山居测试团队的文章
好，那我们就开始把。
还是按照惯例拿出我们前面一直用的测试工程。正好里面有Class A的new操作。直接开始调试
using System;
using System.Collections.Generic;
using System.Text;

namespace TestCPlus
{
class A
{
virtual public void  Say()
{
System.Console.WriteLine(&#34;I Am A.&#34;);
}
}

class B:A
{
override public void  Say()
{
System.Console.WriteLine(&#34;I Am B.&#34;);
}
}
class Program
{
      static void Main()
      {
         A a= new B();
      a.Say();
      }
}
}
其实对于托管代码内的操作，可能有同学会存在无从下手的情况。的确，CLR的托管环境内的互相调用已经进入到了虚拟机的内部，实际操作可能与直观理解差异巨大。但是我们还是可以用我们前面常用的几个方法来解决。
第一个是google大法，在多种姿势搜索后，我们可以了解到如下的一个操作。
/* we usually get the class we need during initialization */
MonoImage *image = mono_assembly_get_image (assembly);
MonoClass *my_class = mono_class_from_name (image, &#34;MyNamespace&#34;, &#34;MyClass&#34;);
...
/* allocate memory for the object */
MonoObject *my_class_instance = mono_object_new (domain, my_class);
/* execute the default argument-less constructor */
mono_runtime_object_init (my_class_instance);
甚至mono都说了
For more complex constructors or if you want to have more control of the execution of the constructor, you can usemono_runtime_invoke()as explained in the previous section, after getting the MonoMethod* representing the constructor:
也就是说mono_runtime_object_init只是负责找到并初始化构造函数的操作。如果想不走正常的构造操作，可以直接调用mono_runtime_invoke手工初始化。也就是mono_runtime_object_init是对mono_runtime_invoke的一个封装。我们看代码也的确如此
void
mono_runtime_object_init (MonoObject *this)
{
MonoMethod *method = NULL;
MonoClass *klass = this->vtable->klass;

method = mono_class_get_method_from_name (klass, &#34;.ctor&#34;, 0);
g_assert (method);

if (method->klass->valuetype)
this = mono_object_unbox (this);
mono_runtime_invoke (method, this, NULL, NULL);
}
接下来我们看最重要的
/**
* mono_object_new:
* @klass: the class of the object that we want to create
*
* Returns: a newly created object whose definition is
* looked up using @klass. This will not invoke any constructors,
* so the consumer of this routine has to invoke any constructors on
* its own to initialize the object.
*
* It returns NULL on failure.
*/
MonoObject *
mono_object_new (MonoDomain *domain, MonoClass *klass)
{
MonoVTable *vtable;

MONO_ARCH_SAVE_REGS;
vtable = mono_class_vtable (domain, klass);
if (!vtable)
return NULL;
return mono_object_new_specific (vtable);
}
mono_object_new是官方文档推荐的mono api，我们可以调用这个函数来生成一个新的MonoObject。其实看代码比较简单。一路跟下去大概是这样子的
mono!mono_object_new
->mono!mono_object_new_specific
-->mono!mono_object_new_alloc_specific
--->贝姆GC提供的malloc里面比较有意思的是mono_object_new_alloc_specific这个函数。
MonoObject *
mono_object_new_alloc_specific (MonoVTable *vtable)
{
MonoObject *o;

if (!vtable->klass->has_references)
      {
o = mono_object_new_ptrfree (vtable);
}
      else if (vtable->gc_descr != GC_NO_DESCRIPTOR)
      {
o = mono_object_allocate_spec (vtable->klass->instance_size, vtable);
}
      else
      {
/* printf(&#34;OBJECT: %s.%s.\n&#34;, vtable->klass->name_space, vtable->klass->name); */
o = mono_object_allocate (vtable->klass->instance_size, vtable);
}
if (G_UNLIKELY (vtable->klass->has_finalize))
mono_object_register_finalizer (o);

if (G_UNLIKELY (profile_allocs))
mono_profiler_allocation (o, vtable->klass);
return o;
}
里面对是否还有引用（has_references），还有GC的描述符都进行了处理
if (G_UNLIKELY (profile_allocs))
mono_profiler_allocation (o, vtable->klass);
这一段也很有意思，mono会对所有的allocation做一个记录，记录下当前申请后返回的MonoObject o，和当前的申请的类所在的信息。如果有兴趣可以在这个mono_profiler_allocation里面做个回调，处理一下对应的信息，打日志或者做个数组存起来都是很不错的方法。然后mono的new的操作就这样结束了，是的你没看错，就这样结束了。。
如果你只是调用mono_object_new来申请mono对象的话，到此，你的对象已经申请好了。
可能有同学会问，但是上文中
      static void Main()
      {
         A a= new B();
      a.Say();
      }
new B()这个操作是怎样在mono CLR里面解码并且触发mono_object_new的操作一点都没有讲来着。
不错，对于new B()这个C#代码编程CIL后怎样在CLR内执行的逻辑我们还没有涉及。对于IL的解码我们还是看mono_method_to_ir这个函数，我们在函数内搜搜是否有我们感兴趣的地方。比如有new 或者object的操作码。随便写个CEE_NewObject。一下就搜到了
case CEE_NEWOBJ: {
MonoInst *iargs [2];
MonoMethodSignature *fsig;
MonoInst this_ins;
MonoInst *alloc;
MonoInst *vtable_arg = NULL;

CHECK_OPSIZE (5);
token = read32 (ip + 1);
cmethod = mini_get_method (cfg, method, token, NULL, generic_context);
if (!cmethod)
goto load_error;
fsig = mono_method_get_signature (cmethod, image, token);
if (!fsig)
goto load_error;

mono_save_token_info (cfg, image, token, cmethod);
                     ...
               }
你看，这个代码一看就很靠谱，我们结合一下生产的CIL代码阅读更佳
.method /*06000006*/ private hidebysig static
      void  Main() cil managed
// SIG: 00 00 01
{
  // Method begins at RVA 0x211c
  // Code size    13 (0xd)
  .maxstack  2
  .locals /*11000001*/ init (class TestCPlus.A/*02000002*/ V_0)
  IL_0000:  /* 73 | (06)000003    */ newobj    instance void TestCPlus.B/*02000003*/::.ctor() /* 06000003 */
  IL_0005:  /* 0A |                */ stloc.0
  IL_0006:  /* 06 |                */ ldloc.0
  IL_0007:  /* 6F | (06)000002    */ callvirt instance void TestCPlus.A/*02000002*/::Say() /* 06000002 */
  IL_000c:  /* 2A |                */ ret
} // end of method Program::Main
我们在这个分支处打上断点，然后开始调试。
token = read32 (ip + 1);
这里里面最精髓的代码就是这一句。token = read32(ip +1)
取出来的Token 为0x6000003也就跟我们刚刚il代码里面的这句对应
IL_0000:  /* 73 | (06)000003    */ newobj    instance void TestCPlus.B/*02000003*/::.ctor()
                                                /* 06000003 */那么(06) 000003到底是什么呢？
cmethod = mini_get_method (cfg, method, token, NULL, generic_context);
这句操作是从token里面取到了一个方法，那么怎样可以从token转换到方法呢？仔细跟下去会发现如下这个方法
MonoMethod *
mono_get_method_full (MonoImage *image, guint32 token, MonoClass *klass,
      MonoGenericContext *context)
{
MonoMethod *result;
gboolean used_context = FALSE;

/* We do everything inside the lock to prevent creation races */

mono_image_lock (image);

if (mono_metadata_token_table (token) == MONO_TABLE_METHOD) {
if (!image->method_cache)
image->method_cache = g_hash_table_new (NULL, NULL);
result = g_hash_table_lookup (image->method_cache, GINT_TO_POINTER (mono_metadata_token_index (token)));
} else {
if (!image->methodref_cache)
image->methodref_cache = g_hash_table_new (NULL, NULL);
result = g_hash_table_lookup (image->methodref_cache, GINT_TO_POINTER (token));
}
mono_image_unlock (image);

if (result)
return result;

result = mono_get_method_from_token (image, token, klass, context, &used_context);
if (!result)
return NULL;

mono_image_lock (image);
if (!used_context && !result->is_inflated) {
MonoMethod *result2;
if (mono_metadata_token_table (token) == MONO_TABLE_METHOD)
result2 = g_hash_table_lookup (image->method_cache, GINT_TO_POINTER (mono_metadata_token_index (token)));
else
result2 = g_hash_table_lookup (image->methodref_cache, GINT_TO_POINTER (token));

if (result2) {
mono_image_unlock (image);
return result2;
}

if (mono_metadata_token_table (token) == MONO_TABLE_METHOD)
g_hash_table_insert (image->method_cache, GINT_TO_POINTER (mono_metadata_token_index (token)), result);
else
g_hash_table_insert (image->methodref_cache, GINT_TO_POINTER (token), result);
}

mono_image_unlock (image);

return result;
}
代码看起来超级长，但是我们简单看看，是不是跟我们第七篇文章里面分析的取meta的逻辑很相似？赶紧打开CFF_Exploer看看文件的MetaData
（06）000003实际上就是MetaData的Table 06 方法表里面的第000003个方法。也就是我们上文里面的Class B的构造函数。
IL_0000:  /* 73 | (06)000003    */ newobj    instance void TestCPlus.B至此，关于CLR里面如何解析New obj代码并取到要new的class的方法已经知道了。剩下的就是如何调用到mono_object_new，我们打一下断点，直接F5一下。
00 mono!mono_object_new_alloc_specific
01 mono!mono_object_new_specific+0x127
02 mono!mono_object_new+0x31
03 mono!mono_type_get_object+0x385
04 mono!mono_class_create_runtime_vtable+0xacb
05 mono!mono_class_vtable_full+0xaf
06 mono!mono_class_create_runtime_vtable+0xab5
07 mono!mono_class_vtable_full+0xaf
08 mono!mono_class_vtable+0x12
09 mono!mono_method_to_ir+0x245ce
最终在mono_method_to_ir会触发handle_alloc_from_inst
            else if (context_used)
            {
MonoInst *data;
int rgctx_info;

if (cfg->opt & MONO_OPT_SHARED)
rgctx_info = MONO_RGCTX_INFO_KLASS;
else
rgctx_info = MONO_RGCTX_INFO_VTABLE;
data = emit_get_rgctx_klass (cfg, context_used, cmethod->klass, rgctx_info);

alloc = handle_alloc_from_inst (cfg, cmethod->klass, data, FALSE);
*sp = alloc;
}
然后会触发mono_class_vtable的操作，最终会调用到mono_object_new。有兴趣的同学可以研究一下。

      if (G_UNLIKELY (profile_allocs))
mono_profiler_allocation (o, vtable->klass);
有兴趣的同学可以关注一下上文提到的mono_profiler_allocation，并查找一下mono_profiler_allocation被引用的地方。看mono对于数组和string new操作的处理是怎样的。
下面我们来实现一个简单的Memory Profiler
MonoObject *
mono_object_new_alloc_specific (MonoVTable *vtable)
{
MonoObject *o;

if (!vtable->klass->has_references) {
o = mono_object_new_ptrfree (vtable);
} else if (vtable->gc_descr != GC_NO_DESCRIPTOR) {
o = mono_object_allocate_spec (vtable->klass->instance_size, vtable);
} else {
o = mono_object_allocate (vtable->klass->instance_size, vtable);
}
if (G_UNLIKELY (vtable->klass->has_finalize))
mono_object_register_finalizer (o);
      printf(&#34;\n==================OBJECT: Stack Start======================&#34;);
      mono_jit_walk_stack(print_stack_frame, TRUE, stdout);
      printf(&#34;\n==================OBJECT: Stack End======================&#34;);
      printf(&#34;\nOBJECT: %s.%s. Size %d \n&#34;, vtable->klass->name_space, vtable->klass->name, mono_object_get_size(o));
if (G_UNLIKELY (profile_allocs))
mono_profiler_allocation (o, vtable->klass);
return o;
}
一个朴实无华的printf就可以玩出花来，希望读者也可以动手实践一下。
至此我们关于CLR内new的操作就研究完啦，我们下次再见，拜拜。

		自动登录	找回密码
密码			立即注册

[笔记] Unity mono代码结构分析及阅读（九）——new操作符的实现

本帖子中包含更多资源