/*
 *  Licensed to the Apache Software Foundation (ASF) under one or more
 *  contributor license agreements.  See the NOTICE file distributed with
 *  this work for additional information regarding copyright ownership.
 *  The ASF licenses this file to You under the Apache License, Version 2.0
 *  (the "License"); you may not use this file except in compliance with
 *  the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */

/**
 * @author Intel, Mikhail Y. Fursov
 *
 */

#ifndef _MEMORY_ATTR_H
#define _MEMORY_ATTR_H
#include <iostream>
#include <assert.h>
#include "open/types.h"
#include "VMInterface.h"

namespace Jitrino {

#define UnknownMemoryContextId ((uint64)-1)

//
//  Attributes of memory locations
//
class MemoryAttribute {
public:
    //
    //  Storage class
    //
    enum StorageClass {
        HeapStorage     = 0x01,
        StackStorage    = 0x02,
        JitDataStorage  = 0x04,
        VmDataStorage   = 0x08,
        AnyStorageClass = 0x0F
    };
    //
    //  Context
    //
    class Context {
    public:
        enum Tag {
            NoContext           = 0x00, // cannot be used in any context
            AnyContext          = 0x01, // can be used in any context
            ObjectField         = 0x02,
            ArrayLength         = 0x03,
            ArrayElement        = 0x04,
            VtableAddr          = 0x05, 
            ObjectLock          = 0x06,
            Unboxed             = 0x07, // address of un-boxed value type inside the boxed value type
            StackLocation       = 0x08,
            StackIncomingArg    = 0x09, 
            StaticMethodAddr    = 0x0A,
            VirtualMethodAddr   = 0x0B,
            StringAddr          = 0x0C,
            StaticField         = 0x0D,
            JitConstant         = 0x0E,
            ProfileCounter      = 0x0F,
            ObjectFieldOffset   = 0x10, // not a real address, must be added to an object
            ArrayLengthOffset   = 0x11, // not a real address
            ArrayElementOffset  = 0x12, // not a real address
            NumTags             = 0x13,
        };
    private:
        // Kind of id
        enum IdKind {
            NoId,
            StackId,
            FieldId,
            MethodId,
            CounterId
        };
    public:
        //
        //  Default constructor
        //
        Context() : tag(NoContext), size(0) {
            id.all = UnknownMemoryContextId;
        }
        //
        //  Copy constructor
        //
        Context(const Context & mc) : tag(mc.tag), id(mc.id), size(mc.size) {
        }
        //
        //  Checks if memory location used in this context can be written by JIT'ed code
        //
        static bool isReadOnly(Tag tag) {
            assert(info[tag].tag == tag);
            return !info[tag].canBeWrittenByJittedCode;
        }
        bool    isReadOnly() const {return isReadOnly(tag);}
        //
        //  Checks if memory location used in this context can be written inside calls
        //
        static bool    isKilledByCalls(Tag tag) {
            assert(info[tag].tag == tag);
            return info[tag].killedByCalls;
        }
        bool    isKilledByCalls() const {return isKilledByCalls(tag);}
        //
        //  Checks if managed pointers of different types can refer to the same memory location
        //  that has this context.
        //
        static bool    maybeTypeAliased(Tag tag) {
            assert(info[tag].tag == tag);
            return info[tag].maybeTypeAliased;
        }
        bool    maybeTypeAliased() const {return maybeTypeAliased(tag);}
        //
        //  Storage class queries
        //
        bool    isInHeap() const {return getStorageClass() == HeapStorage;}
        bool    isOnStack() const {return getStorageClass() == StackStorage;}
        bool    maybeInHeap() const {return (getStorageClass() & HeapStorage) != 0;}
        bool    maybeOnStack() const {return (getStorageClass() & StackStorage) != 0;}
        //
        //  Tag queries
        //
        bool    isValid() const {return tag != NoContext;}
        bool    isKnown() const {return tag != AnyContext;}
        //
        //  Tag ids are sequential numbers for tags that allow for easy implementation
        //  of associative containers indexed by tags.
        //  This might be useful if tags become non sequential, e.g., bit positions
        //  so that we can encode multiple tag usage for managed pointers in CLI.
        //
        static U_32  getNumTagIds() {return NumTags;}
        static U_32  getTagId(Tag tag) {return tag;}
        U_32         getTagId() const {return getTagId(tag);}
        static Tag     mapIdToTag(U_32 _id) {return (Tag)_id;}
        //
        //  Checks if memory context is exact
        //
        bool isExact() const {
            assert(info[tag].tag == tag);
            return tag > AnyContext && 
                (info[tag].idKind == NoId || id.all != UnknownMemoryContextId);
        }
        //
        //  Checks if two contexts can refer to the same memory location
        //
        bool maybeAliased(const Context& mc) const;
        //
        //  Checks if two contexts are the same
        //
        bool isEqual(Context& mc) const {
            return tag == mc.tag && getId() == mc.getId() && size == mc.size;
        }
        //
        //  Unions this context with another one
        //
        void unionWith(Context& mc);
        //
        //  Returns tag of the memory context
        //
        Tag getTag() const {return tag;}
        //
        //  Returns storage class of memory locations used in this context
        //
        StorageClass getStorageClass() const {
            assert(info[tag].tag == tag);
            return info[tag].storageClass;
        }
        //
        //  Checks if context can refer to a certain storage class
        //
        bool canReferToStorageClass(StorageClass sc) const {
            return (getStorageClass() & sc) != 0;
        }
        //
        //  Get various ids
        //
        U_32 getStackOffset() const {
            assert(getIdKind() == StackId);
            return id.stackOffset;
        }
        FieldDesc * getFieldDesc() const {
            assert(getIdKind() == FieldId);
            return id.fieldDesc;
        }
        MethodDesc * getMethodDesc() const {
            assert(getIdKind() == MethodId);
            return id.methodDesc;
        }
        U_32     getProfileCounterId() const {
            assert(getIdKind() == CounterId);
            return id.counterId;
        }
        //
        //  Prints tag
        //
    void print(::std::ostream& os) const {
            assert(info[tag].tag == tag);
            os << info[tag].name;
            printId(os);
        }
    protected:
        //
        //  Information about memory contexts
        //
        struct Info {
            Tag          tag;
            const char * name;
            bool         canBeWrittenByJittedCode;
            bool         killedByCalls;
            IdKind       idKind;
            StorageClass storageClass;
            bool         maybeTypeAliased;
        };
    private:
        Context(Tag t, U_32 _size = 0)
            : tag(t), size((U_8)_size) {
            id.all = UnknownMemoryContextId;
            assert(_size <= 0xff);
        }
        void unionIds(uint64 id1) {
            if (id.all != id1)
                id.all = UnknownMemoryContextId;
        }
        void unionSizes(U_8 size1) {
            if (size < size1)
                size = size1;
        }
        IdKind  getIdKind() const {
            assert(info[tag].tag == tag);
            return info[tag].idKind;
        }
        bool    hasUnknownId() const {return id.all == UnknownMemoryContextId;}
        U_32  getId() const;
    void    printId(::std::ostream& os) const;
        //
        // Fields
        //
        Tag      tag : 8;
        union IdUnion {
            U_32       stackOffset;
            FieldDesc *  fieldDesc;
            MethodDesc * methodDesc;
            U_32       counterId;
            uint64       all;
        } id;
        U_8    size; // size of accessed memory in bytes; used for stack locations
        static Info info[];
        friend class MemoryAttributeManager;
    };  // end class Context
};

//
//  Memory attribute manager
//
class MemoryAttributeManager {
public:
    //
    //  Factory methods to create various memory contexts
    //
    MemoryAttribute::Context getUnknownContext() {
        return MemoryAttribute::Context(MemoryAttribute::Context::AnyContext);
    }
    MemoryAttribute::Context getObjectFieldContext(FieldDesc * fieldDesc) {
        MemoryAttribute::Context c(MemoryAttribute::Context::ObjectField);
        c.id.fieldDesc = fieldDesc;
        return c;
    }
    MemoryAttribute::Context getArrayLengthContext() {
        return MemoryAttribute::Context(MemoryAttribute::Context::ArrayLength);
    }
    MemoryAttribute::Context getArrayElementContext() {
        return MemoryAttribute::Context(MemoryAttribute::Context::ArrayElement);
    }
    MemoryAttribute::Context getVtableAddrContext() {
        return MemoryAttribute::Context(MemoryAttribute::Context::VtableAddr);
    }
    MemoryAttribute::Context getObjectLockContext() {
        return MemoryAttribute::Context(MemoryAttribute::Context::ObjectLock);
    }
    MemoryAttribute::Context getUnboxedContext() {
        return MemoryAttribute::Context(MemoryAttribute::Context::Unboxed);
    }
    MemoryAttribute::Context getObjectFieldOffsetContext(FieldDesc * fieldDesc) {
        MemoryAttribute::Context c(MemoryAttribute::Context::ObjectFieldOffset);
        c.id.fieldDesc = fieldDesc;
        return c;
    }
    MemoryAttribute::Context getArrayLengthOffsetContext() {
        return MemoryAttribute::Context(MemoryAttribute::Context::ArrayLengthOffset);
    }
    MemoryAttribute::Context getArrayElementOffsetContext() {
        return MemoryAttribute::Context(MemoryAttribute::Context::ArrayElementOffset);
    }
    MemoryAttribute::Context getAddressContextFromOffsetContext(MemoryAttribute::Context &offsetContext) {
        switch (offsetContext.tag) {
        case MemoryAttribute::Context::ObjectFieldOffset:
            return getObjectFieldContext(offsetContext.getFieldDesc());
        case MemoryAttribute::Context::ArrayLengthOffset:
            return getArrayLengthContext();
        case MemoryAttribute::Context::ArrayElementOffset:
            return getArrayElementContext();
        default:
            break;
        }
        assert(0);
        return getUnknownContext();
    }
    //
    // Get memory context for accessing stack memory of given size at given offset
    //
    MemoryAttribute::Context getStackContext(U_32 offset, U_32 size) {
        assert(size <= 0xff);
        MemoryAttribute::Context c(MemoryAttribute::Context::StackLocation,
                                   (U_8)size);
        c.id.stackOffset = offset;
        return c;
    }
    //
    //  Get memory context for accessing a stack incoming argument at given slot.
    //  This is IPF specific as incoming arguments are in the previous frame
    //  and their stack offset is not known till the final register allocation.
    //
    MemoryAttribute::Context getStackIncomingArgContext(U_32 offset) {
        MemoryAttribute::Context c(MemoryAttribute::Context::StackIncomingArg);
        c.id.stackOffset = offset;
        return c;
    }
    MemoryAttribute::Context getStaticMethodAddrContext(MethodDesc * desc) {
        MemoryAttribute::Context c(MemoryAttribute::Context::StaticMethodAddr);
        c.id.methodDesc = desc;
        return c;
    }
    MemoryAttribute::Context getVirtualMethodAddrContext(MethodDesc * desc) {
        MemoryAttribute::Context c(MemoryAttribute::Context::VirtualMethodAddr);
        c.id.methodDesc = desc;
        return c;
    }
    MemoryAttribute::Context getStringAddrContext() {
        return MemoryAttribute::Context(MemoryAttribute::Context::StringAddr);
    }
    MemoryAttribute::Context getStaticFieldContext(FieldDesc * fieldDesc) {
        MemoryAttribute::Context c(MemoryAttribute::Context::StaticField);
        c.id.fieldDesc = fieldDesc;
        return c;
    }
    MemoryAttribute::Context getJitConstantContext() {
        return MemoryAttribute::Context(MemoryAttribute::Context::JitConstant);
    }
    MemoryAttribute::Context getProfileCounterContext(U_32 counterId) {
        MemoryAttribute::Context c(MemoryAttribute::Context::ProfileCounter);
        c.id.counterId = counterId;
        return c;
    }
    //
    //  Returns a memory context at (offset, size) from the given context
    //
    MemoryAttribute::Context findContextAtOffset(MemoryAttribute::Context& mc,
                                                 U_32                    _offset,
                                                 U_32                    _size) {
        MemoryAttribute::Context context(mc);
        if (context.tag == MemoryAttribute::Context::StackLocation ||
            context.tag == MemoryAttribute::Context::StackIncomingArg) {
            assert(_size <= 0xff);
            context.size = (U_8)_size;
            if (context.id.all != UnknownMemoryContextId)
                context.id.stackOffset += _offset;
        }
        return context;
    }
};

} //namespace Jitrino 

#endif