Android内核源码Abi目录学习笔记

好记性不如烂笔头，今天要学习的是Android中Abi目录下的代码。下面是基本的学习的笔记的汇总。

首先是include中的头文件的说明。

在cxxabi的头文件中主要需要掌握下面的几个点：

1、这个头文件中包含的主要的功能就是基于C++ 2.9.5中的驱动的类型的信息。

2、驱动的类型这里面主要定义了这么几类：

2、1  __fundamental_type_info  基本驱动类型的信息

2、2 __array_type_info 数组驱动类型的信息

2、3 __function_type_info函数驱动类型的信息

2、4 __enum_type_info枚举驱动类型的信息

2、5 __class_type_info没有父类的类的驱动类型的信息

2、7 __si_class_type_info是__class_type_info的子类，其中包含了一个单例、公有非虚的，偏移量为0的指向的是__class_type_info的类型的指针。

const __class_type_info *__base_type;

在new的头文件中主要需要掌握下面的几个点：

1、主要是一些操作符的重载

2、被重载的操作符主要有：new 、new[ ]、delete、delete[ ]

2、同时每一个操作符的重载基本上都要声明抛出异常

在typeinfo的头文件中需要掌握下面的几个点：

1、主要是定义了type_info的一些操作（主要还是一些操作符的重载）（基于C++ 2.9.3的片段）

接下来是src中的源码文件的说明。

1、主要是一些驱动类型的信息的实现，其中绝大多数的实现是一些空实现，仅仅包括一个析构函数。

2、其中数组驱动类型、类驱动类型、枚举驱动类型、函数驱动类型、基本数据驱动类型、指针指向成员变量驱动类型、指针驱动类型等都是处了有一个析构函数的空的定义，其余什么都没有的源码。

3、对于delete运算符重载的实现是下面这样的：

void
operator delete(void* ptr) throw()
{
  if (ptr)
    free(ptr);
}

调用free方法释放指向的存储空间。

4、对于new运算符的重载方法如下：

void*
operator new(std::size_t size) throw (/*std::bad_alloc*/)
{
  void* ptr = malloc(size);
#if 0
  if (ptr == NULL)
    throw std::bad_alloc();
#endif
  return ptr;
}

调用malloc函数分配需要的存储空间，如果分配失败，抛出异常。

5、在dynamic_cast的源码中，需要注意下面的几个点：

5、1  通过偏移量调整一个指针的指向

5、2  返回一个通过指针指向的多态的对象的指针的虚拟表

5、3  返回在一个虚拟表中的一个指针指向的类驱动类型的信息

5、4  返回在一个虚拟表中，相对于一个对象的偏移量。

5、5  如何去迭代一个对象的类型的树

  const void *
  walk_object(const void *object,
              const abi::__class_type_info *type,
              const void *match_object,
              const abi::__class_type_info *match_type)
  {
//如果当前的对象的类型与当前的等待迭代的指针是相同的
 if (*type == *match_type)
      return (match_object == NULL || object == match_object) ? object : NULL;

    switch(type->code())
      {
      case abi::__class_type_info::CLASS_TYPE_INFO_CODE:
        // This isn't not the class you're looking for.
        return NULL;

      case abi::__class_type_info::SI_CLASS_TYPE_INFO_CODE:
        // derived type has a single public base at offset 0.
        {
          const abi::__si_class_type_info* ti =
            static_cast<const abi::__si_class_type_info*>(type);
          return walk_object(object, ti->__base_type, match_object,
                             match_type);
        }

      case abi::__class_type_info::VMI_CLASS_TYPE_INFO_CODE:
        {
          const void* vtable = get_vtable(object);
          const abi::__vmi_class_type_info* ti =
            static_cast<const abi::__vmi_class_type_info*>(type);

          // Look at all direct bases.
          const void* result = NULL;
          for (unsigned i = 0; i < ti->__base_count; ++i)
            {
              if (!ti->__base_info[i].is_public())
                continue;

              const void *subobject =
                get_subobject(object, vtable, &ti->__base_info[i]);
              const void* walk_subobject_result =
                walk_object(subobject, ti->__base_info[i].__base_type,
                            match_object, match_type);

              if (walk_subobject_result == ambiguous_object)
                return ambiguous_object;
              else if (walk_subobject_result != NULL)
                {
                  if (result == NULL)
                    {
                      result = walk_subobject_result;
                    }
                  else if (result != walk_subobject_result)
                    return ambiguous_object;
                }
            }
          return result;
        }

      default:
        assert(0);
      }
    return NULL;
  }