/* vim: set ts=4 sw=4 tw=99 et:

  *

  * Copyright (C) 2012 David Anderson

  *

  * This file is part of JITCraft.

  *

  * JITCraft is free software: you can redistribute it and/or modify it under

  * the terms of the GNU General Public License as published by the Free

  * Software Foundation, either version 3 of the License, or (at your option)

  * any later version.

  * 

  * Foobar is distributed in the hope that it will be useful, but WITHOUT ANY

  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS

  * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

  *

  * You should have received a copy of the GNU General Public License along with

  * JITCraft. If not, see http://www.gnu.org/licenses/.

  */

 #ifndef _include_jc_object_visitor_h_

 #define _include_jc_object_visitor_h_

 #include "Objects.h"

 #include "Types.h"

 #include "FixedArray.h"

 #include "Code.h"

 #include "Reference.h"

 #include "Modules.h"

 #include "Functions.h"

 #include "Array.h"

 #include "Strings.h"

 #include "Environments.h"

 namespace ke {

 // An ObjectVisitor is used for traversing object references in the heap. Since

 // this pattern must be lightning fast, we avoid virtual dispatch by forcing

 // visitors to compose themselves with the visiting logic.

 template <typename T>

 class ObjectVisitor : public T

 {

   private:

     void visitField(Object *obj, size_t offset) {

         this->visit(reinterpret_cast<Object **>(Address(obj) + offset));

     }

     size_t iterateType(Object *obj) {

         visitField(obj, Type::offsetOfContained());

         visitField(obj, Type::offsetOfReturnType());

         visitField(obj, Type::offsetOfParameters());

         visitField(obj, Type::offsetOfTag());

         return sizeof(Type);

     }

     size_t iterateFixedArray(FixedArray *array) {

         unsigned length = array->length();

         Object **ptr = reinterpret_cast<Object **>(array + 1);

         for (unsigned i = 0; i < length; i++)

             this->visit(ptr + i);

         return FixedArray::SizeFor(length);

     }

     size_t iterateByteArray(ByteArray *array) {

         return ByteArray::SizeFor(array->length());

     }

     size_t iterateCode(Object *obj) {

         visitField(obj, Code::offsetOfModule());

         visitField(obj, Code::offsetOfBytecode());

         visitField(obj, Code::offsetOfLocals());

         visitField(obj, Code::offsetOfObjects());

         visitField(obj, Code::offsetOfSafepoints());

         visitField(obj, Code::offsetOfSourceMap());

         return sizeof(Code);

     }

     size_t iterateReference(Object *obj) {

         visitField(obj, Reference::offsetOfBase());

         return sizeof(Reference);

     }

     size_t iterateModule(Object *obj) {

         visitField(obj, Module::offsetOfFunctions());

         visitField(obj, Module::offsetOfPublics());

         visitField(obj, Module::offsetOfNatives());

         visitField(obj, Module::offsetOfFile());

         visitField(obj, Module::offsetOfEnvironment());

         visitField(obj, Module::offsetOfCode());

         return sizeof(Module);

     }

     size_t iterateFunction(Object *obj) {

         visitField(obj, Function::offsetOfCode());

         visitField(obj, Function::offsetOfType());

         visitField(obj, Function::offsetOfName());

         return sizeof(Function);

     }

     size_t iterateNative(Object *obj) {

         visitField(obj, Native::offsetOfType());

         visitField(obj, Native::offsetOfName());

         return sizeof(Native);

     }

     size_t iterateString(Object *obj) {

         return String::SizeFor(String::cast(obj)->length());

     }

     size_t iterateArray(Array *array, ArrayMap *map) {

         assert(map->type()->isArray());

         if (map->contained()) {

             unsigned length = array->nelements();

             Object **vec = array->objVec();

             for (unsigned i = 0; i < length; i++)

                 this->visit(vec + i);

         }

         return Array::SizeOf(array);

     }

     size_t iterateArrayMap(ArrayMap *map) {

         visitField(map, ArrayMap::offsetOfType());

         visitField(map, ArrayMap::offsetOfContained());

         return sizeof(ArrayMap);

     }

     size_t iterateEnvironmentSlotDescriptorArray(EnvironmentSlotDescriptorArray *env) {

         unsigned length = env->length();

         EnvironmentSlotDescriptor *desc = env->slots();

         for (unsigned i = 0; i < length; i++)

             this->visit(desc->type.addr());

         return env->size();

     }

     size_t iterateEnvironmentMap(EnvironmentMap *map) {

         visitField(map, EnvironmentMap::offsetOfSlots());

         return map->size();

     }

     size_t iterateEnvironment(Environment *env) {

         EnvironmentMap *map = env->map();

         const unsigned *offsets = map->traceOffsets();

         unsigned noffsets = map->traceOffsetCount();

         for (unsigned i = 0; i < noffsets; i++)

             visitField(env, Environment::offsetOfSlotOffset(offsets[i]));

         return env->size();

     }

   public:

     size_t iterate(Object *obj) {

         visitField(obj, Object::offsetOfMap());

         return iterate(obj, obj->map());

     }

     size_t iterate(Object *obj, Map *map) {

         switch (map->kind()) {

           case MapKind_Type:

             return iterateType(obj);

           case MapKind_FixedArray:

             return iterateFixedArray(FixedArray::cast(obj));

           case MapKind_ByteArray:

             return iterateByteArray(ByteArray::cast(obj));

           case MapKind_Code:

             return iterateCode(obj);

           case MapKind_Reference:

             return iterateReference(obj);

           case MapKind_Module:

             return iterateModule(obj);

           case MapKind_Function:

             return iterateFunction(obj);

           case MapKind_String:

             return iterateString(obj);

           case MapKind_Array:

             return Align(iterateArray(Array::cast(obj), ArrayMap::cast(map)), kObjectAlignment);

           case MapKind_EnvironmentSlotDescriptorArray:

             return iterateEnvironmentSlotDescriptorArray(EnvironmentSlotDescriptorArray::cast(obj));

           case MapKind_Environment:

             return iterateEnvironment(Environment::cast(obj));

           case MapKind_Native:

             return iterateNative(obj);

           case MapKind_MetaArray:

             return iterateArrayMap(ArrayMap::cast(obj));

           case MapKind_MetaEnvironment:

             return iterateEnvironmentMap(EnvironmentMap::cast(obj));

           default:

             assert(map->kind() == MapKind_Meta);

             return sizeof(Map);

         }

     }

 };

 static inline size_t

 SizeOfObject(Object *obj, Map *map)

 {

     switch (map->kind()) {

       case MapKind_Type:

         return sizeof(Type);

       case MapKind_FixedArray:

         return FixedArray::SizeFor(FixedArray::cast(obj)->length());

       case MapKind_ByteArray:

         return ByteArray::SizeFor(ByteArray::cast(obj)->length());

       case MapKind_Code:

         return sizeof(Code);

       case MapKind_Reference:

         return sizeof(Reference);

       case MapKind_Module:

         return sizeof(Module);

       case MapKind_Function:

         return sizeof(Function);

       case MapKind_String:

         return String::SizeFor(String::cast(obj)->length());

       case MapKind_Native:

         return sizeof(Native);

       case MapKind_Array:

         return Align(Array::SizeOf(Array::cast(obj)), kObjectAlignment);

       case MapKind_EnvironmentSlotDescriptorArray:

         return EnvironmentSlotDescriptorArray::cast(obj)->size();

       case MapKind_Environment:

         return Environment::cast(obj)->size();

       case MapKind_MetaArray:

         return sizeof(ArrayMap);

       case MapKind_MetaEnvironment:

         return EnvironmentMap::cast(obj)->size();

       case MapKind_FreeRegion:

         return *reinterpret_cast<size_t *>(reinterpret_cast<Address>(obj + 1));

       default:

         assert(map->kind() == MapKind_Meta);

         return sizeof(Map);

     }

 }

 class ObjectSizeEvaluator

 {

   public:

     size_t operator()(Object *obj, Map *map) {

         return SizeOfObject(obj, map);

     }

 };

 }

 #endif // _include_jc_object_visitor_h_