/*

 * 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_jitcraft_objects_h_

#define _include_jitcraft_objects_h_

#include "Utility.h"

#include "Spaces.h"

#include "Barriers.h"

namespace jc {

class Zone;

// Macros for laying out objects.

#define OBJECT_FIELD(Type, name)                    \

    Type fld_##name##_;

// :TODO: refactor these now that objects are no longer tagged.

#define RAW_FIELD_ADDRESS(ptr)                      \

    (reinterpret_cast<uintptr_t>(ptr))

#define TYPED_FIELD_ADDRESS(Type, ptr)              \

    (reinterpret_cast<Type *>(RAW_FIELD_ADDRESS(ptr)))

#define OBJ_FIELD_OFFSET(obj, ptr)                  \

    (reinterpret_cast<uintptr_t>(ptr) - reinterpret_cast<uintptr_t>(obj))

#define READ_FIELD(name)                            \

    read(&fld_##name##_)

#define WRITE_FIELD(name, val)                      \

    write(&fld_##name##_, val)

#define READ_FIELD_OBJ(name)                        \

    read(reinterpret_cast<Object **>(&fld_##name##_))

#define WRITE_FIELD_OBJ(env, name, val)             \

    write(env, reinterpret_cast<Object **>(&fld_##name##_), val)

#define WRITE_FIELD_OBJ_NO_BARRIER(name, val)  \

    writeNoBarrier(reinterpret_cast<Object **>(&fld_##name##_), val)

// Garbage-collection objects require a header to describe their layout. This

// header is called a "map". The different kinds of maps are enumerated below.

class Map;

enum MapKind

{

    // Represents Type objects.

    MapKind_Type,

    // Represents basic data structures. When adding to this, don't forget

    // to update Zone::initialize(), or you'll get a NULL crash trying to

    // allocate, since these maps are cached.

    MapKind_FixedArray,

    MapKind_ByteArray,

    MapKind_Code,

    MapKind_Reference,

    MapKind_Module,

    MapKind_Function,

    // Used to represent Arrays. This does not have a canonical map.

    MapKind_Array,

    // These represent special Map subclasses that require special tracing.

    MapKinds_Special,

    MapKind_Meta,           // (default map class)

    MapKind_MetaArray,      // ArrayMap instances

    MapKinds_EndSpecial,

    MapKinds_Total

};

typedef void * VoidPtr;

// All garbage collected objects must inherit from GCObject. Note that using

// virtual functions is illegal, as the |map| field would be displaced.

class Object

{

    Barriered<Map> map_;

  public:

    void init(Map *map) {

        map_ = map;

    }

    Map *map() {

        return map_;

    }

    inline bool is(MapKind map);

    inline void write(Zone *zone, Object **ptr, Object *value);

};

// Maps describe the layout of GCObjects. Every GCObject requires a map.

class Map : public Object

{

    MapKind kind_;

  public:

    void setKind(MapKind kind) {

        kind_ = kind;

    }

    MapKind kind() {

        return kind_;

    }

    static inline Map *cast(Object *obj) {

        // Note that ArrayMap is a map, but a special one: since it is non-

        assert(obj->map()->kind() > MapKinds_Special &&

               obj->map()->kind() < MapKinds_EndSpecial);

        return reinterpret_cast<Map *>(obj);

    }

};

// Heap-allocated objects go here. Heaps are thread-local.

class Heap

{

    Zone *zone_;

    HeapStack lifoSpace_;

    OldSpace mapSpace_;

    OldSpace oldSpace_;

    Map *metaMap_;

  public:

    enum Tenure {

        // Default, objects go into the nursery.

        Tenure_Default,

        // If objects are proven to not escape the stack, they can go into

        // a LIFO arena. Allocation on the LIFO arena is not guaranteed to

        // succeed; thus, objects may still be allocated in other arenas.

        Tenure_Stack,

        // Objects that should not go into the nursery (i.e. are expected

        // to be long-living) go here.

        Tenure_Old

    };

  private:

    Address newOldObject(size_t bytes);

    inline Address newStackObject(size_t bytes);

    inline Address newObject(size_t bytes, Tenure pretenure);

  public:

    Heap(Zone *zone);

    bool initialize();

    inline Object *allocate(Map *map, size_t byes, Tenure pretenure);

    inline Object *allocate(Handle<Map> map, size_t byes, Tenure pretenure);

    Map *allocateMap(MapKind kind, size_t bytes);

    Map *metaMap() {

        return metaMap_;

    }

    inline Address lifoPosition() const {

        return lifoSpace_.position();

    }

    inline void unwindLifo(Address to) {

        lifoSpace_.unwind(to);

    }

};

inline bool

Object::is(MapKind kind)

{

    return map()->kind() == kind;

}

}

#endif //_include_jitcraft_objects_h_