/*
  Copyright (C) 2010-2013 David Anderson.  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
  * Redistributions of source code must retain the above copyright
    notice, this list of conditions and the following disclaimer.
  * Redistributions in binary form must reproduce the above copyright
    notice, this list of conditions and the following disclaimer in the
    documentation and/or other materials provided with the distribution.
  * Neither the name of the example nor the
    names of its contributors may be used to endorse or promote products
    derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY David Anderson ''AS IS'' AND ANY
  EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL David Anderson BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

*/


//
// irepdie.h
//
//
class IRCUdata;
class IRDie;

class IRAttr {
public:
    IRAttr():attr_(0),finalform_(0),initialform_(0),
        formclass_(DW_FORM_CLASS_UNKNOWN),formdata_(0) {
        };
    IRAttr(Dwarf_Half attr,Dwarf_Half finalform, Dwarf_Half initialform):
        attr_(attr),finalform_(finalform),initialform_(initialform),
        formclass_(DW_FORM_CLASS_UNKNOWN),formdata_(0) {
    };
    IRAttr(const IRAttr &r) {
        attr_ = r.attr_;
        finalform_ = r.finalform_;
        initialform_ = r.initialform_;
        formclass_ = r.formclass_;
        if(r.formdata_) {
            formdata_ =  r.formdata_->clone();
        } else {
            formdata_ = 0;
        }
    };
    ~IRAttr() { delete formdata_; };
    IRAttr & operator=( const IRAttr &r) {
        if(this == &r) {
            return *this;
        }
        attr_ = r.attr_;
        finalform_ = r.finalform_;
        initialform_ = r.initialform_;
        formclass_ = r.formclass_;
        if(r.formdata_) {
            formdata_ =  r.formdata_->clone();
        } else {
            formdata_ = 0;
        }
        return *this;
    }
    void setBaseData(Dwarf_Half attr, Dwarf_Half finalform,
        Dwarf_Half initialform){
        attr_ = attr;
        finalform_ = finalform;
        initialform_ = initialform;
    };
    void setFormClass(enum Dwarf_Form_Class cl) {
        formclass_ = cl;
    };
    enum Dwarf_Form_Class getFormClass() const {return formclass_; };
    void setFormData(IRForm *f) { formdata_ = f; };
    Dwarf_Half getFinalForm() const { return initialform_; };
    Dwarf_Half getDirectForm() const { return finalform_; };
    Dwarf_Half getAttrNum() const { return attr_; };
    IRForm * getFormData() { return formdata_;};
private:
    Dwarf_Half attr_;
    Dwarf_Half finalform_;
    // In most cases finalform == initialform form.
    // Otherwise, initialform == DW_FORM_indirect.
    Dwarf_Half initialform_;
    enum Dwarf_Form_Class formclass_;
    IRForm *formdata_;
};

class IRDie {
public:
    IRDie():tag_(0),globalOffset_(0), cuRelativeOffset_(0),
        generatedDie_(0) {};
    ~IRDie() {};
    void addChild(const IRDie & newdie ) {
        children_.push_back(newdie);
    };
    std::string  getName() {
        std::list<IRAttr>::iterator it = attrs_.begin();
        for( ; it != attrs_.end() ; ++it) {
            if (it->getAttrNum() == DW_AT_name) {
                IRForm *f = it->getFormData();
                const IRFormString * isv =
                    dynamic_cast<const IRFormString *>(f);
                if(isv) {
                    return isv->getString();
                }
            }
        }
        return "";
    };
    std::list<IRAttr> & getAttributes() {return attrs_; };
    std::list<IRDie> & getChildren() {return children_; };
    bool hasNewestChild(IRDie **lastch) { size_t N = children_.size();
        if(N < 1) {
            return false;
        }
        *lastch = &children_.back();
        return true;
    };
    // lastChild and lastAttr will throw if no entry exists.
    IRDie &lastChild() { return children_.back(); };
    IRAttr &lastAttr() { return attrs_.back(); };
    void setBaseData(Dwarf_Half tag,Dwarf_Unsigned goff,
        Dwarf_Unsigned cuoff) {
        tag_ = tag;
        globalOffset_=goff;
        cuRelativeOffset_ = cuoff;
    };
    Dwarf_Unsigned getGlobalOffset() const { return globalOffset_;};
    Dwarf_Unsigned getCURelativeOffset() const { return cuRelativeOffset_;};
    void setGeneratedDie(Dwarf_P_Die p_die) {
        generatedDie_ = p_die;};
    Dwarf_P_Die getGeneratedDie() const { return generatedDie_;};
    unsigned getTag() {return tag_; }

private:
   // We rely on the IRDie container being one which does not
   // invalidate pointers with addition/deletion.
   std::list<IRDie>  children_;

   std::list<IRAttr> attrs_;
   unsigned tag_;
   // The following are data from input.
   Dwarf_Unsigned globalOffset_;
   Dwarf_Unsigned cuRelativeOffset_;

   // the following is generated during output.
   Dwarf_P_Die generatedDie_;
};


struct OffsetFormEntry {
    OffsetFormEntry(): off_(0),form_(0){};
    OffsetFormEntry(Dwarf_Unsigned o,
        IRFormReference* f): off_(o),form_(f){};
    ~OffsetFormEntry(){};

    Dwarf_Unsigned  off_;
    IRFormReference *form_;
};
struct ClassReferenceFixupData {
    ClassReferenceFixupData():
        dbg_(0),
        attrnum_(0),
        sourcedie_(0),
        target_(0) {}
    ~ClassReferenceFixupData(){};
    ClassReferenceFixupData(
        Dwarf_P_Debug dbg,
        Dwarf_Half attrnum,
        Dwarf_P_Die sourcedie,
        IRDie *d):
        dbg_(dbg),
        attrnum_(attrnum),
        sourcedie_(sourcedie),
        target_(d) {};
    Dwarf_P_Debug dbg_;
    //  The source die and attrnum suffice because the definition of
    //  DWARF guarantees only one attribute of any given attribute number
    //  can exist on a given DIE.
    Dwarf_Half attrnum_;
    Dwarf_P_Die sourcedie_;
    IRDie *target_;
};

class IRCUdata {
public:
    IRCUdata():
        cu_header_length_(0),
        abbrev_offset_(0),
        next_cu_header_offset_(0),
        version_stamp_(0),
        address_size_(0),
        length_size_(0),
        extension_size_(0),
        has_macrodata_(false),
        macrodata_offset_(0),
        has_linedata_(false),
        linedata_offset_(0),
        cudie_offset_(0)
        {};
    IRCUdata(Dwarf_Unsigned len,Dwarf_Half version,
        Dwarf_Unsigned abbrev_offset,
        Dwarf_Half addr_size,
        Dwarf_Half length_size,
        Dwarf_Half extension_size,
        Dwarf_Unsigned next_cu_header):
            cu_header_length_(len),
            abbrev_offset_(abbrev_offset),
            next_cu_header_offset_(addr_size),
            version_stamp_(version),
            address_size_(addr_size),
            length_size_(length_size),
            extension_size_(extension_size),
            has_macrodata_(false),
            macrodata_offset_(0),
            has_linedata_(false),
            linedata_offset_(0),
            cudie_offset_(0) {};
    ~IRCUdata() { };
    bool hasMacroData(Dwarf_Unsigned *offset_out,Dwarf_Unsigned *cudie_off) {
        *offset_out = macrodata_offset_;
        *cudie_off = cudie_offset_;
        return has_macrodata_;
    }
    bool hasLineData(Dwarf_Unsigned *offset_out,Dwarf_Unsigned *cudie_off) {
        *offset_out = linedata_offset_;
        *cudie_off = cudie_offset_;
        return has_linedata_;
    }
    void setMacroData(Dwarf_Unsigned offset,Dwarf_Unsigned cudieoff) {
        has_macrodata_ = true;
        macrodata_offset_ = offset;
        cudie_offset_ = cudieoff;
    };
    void setLineData(Dwarf_Unsigned offset,Dwarf_Unsigned cudieoff) {
        has_linedata_ = true;
        linedata_offset_ = offset;
        cudie_offset_ = cudieoff;
    };
    IRDie & baseDie() { return cudie_; };
    Dwarf_Half getVersionStamp() { return version_stamp_; };
    Dwarf_Half getOffsetSize() { return length_size_; };
    Dwarf_Unsigned getCUdieOffset() { return cudie_offset_; };
    IRCULineData & getCULines() { return cu_lines_; };

    void insertLocalDieOffset(Dwarf_Unsigned localoff,IRDie* dieptr) {
        cuOffInLocalToIRDie_[localoff] = dieptr;
    };
    void insertLocalReferenceAttrTargetRef(Dwarf_Unsigned localoff,
        IRFormReference* attrptr) {

        cuOffInLocalToIRFormRef_.push_back(OffsetFormEntry(localoff,
            attrptr));
    };
    IRDie * getLocalDie(Dwarf_Unsigned localoff) {
        std::map<Dwarf_Unsigned,IRDie*>::iterator pos;
        pos = cuOffInLocalToIRDie_.find(localoff);
        if(pos != cuOffInLocalToIRDie_.end()) {
            return pos->second;
        }
        return NULL;
    };
    void insertClassReferenceFixupData(ClassReferenceFixupData &c) {
        classReferenceFixupList_.push_back(c);
    }
    void updateClassReferenceTargets();
    std::string  getCUName() {
        return cudie_.getName();
    };
    // Use  cuOffInLocalToIRDie_ and
    // cuOffInLocalToIRAttr_ to update attr targets.
    void updateReferenceAttrDieTargets() {
        for(std::list<OffsetFormEntry>::iterator it =
            cuOffInLocalToIRFormRef_.begin();
            it != cuOffInLocalToIRFormRef_.end();
            ++it) {
            IRFormReference* r = it->form_;
            IRDie * tdie = getLocalDie(it->off_);
            if(tdie) {
                r->setTargetInDie(tdie);
            } else {
                // Missing die in r
                // Should be impossible.
            }
        }
    }

private:
    Dwarf_Unsigned cu_header_length_;
    Dwarf_Unsigned abbrev_offset_;
    Dwarf_Unsigned next_cu_header_offset_;
    Dwarf_Half  version_stamp_;
    Dwarf_Half address_size_;
    Dwarf_Half length_size_;
    Dwarf_Half extension_size_;
    bool has_macrodata_;
    Dwarf_Unsigned macrodata_offset_;
    bool has_linedata_;
    Dwarf_Unsigned linedata_offset_;
    Dwarf_Unsigned cudie_offset_;
    IRCULineData      cu_lines_;

    // If true, is 32bit dwarf,else 64bit. Gives the size of a reference.
    bool dwarf32bit_;

    IRDie   cudie_;

    // Refers to cu-local offsets in the input CU and which DIE
    // in the input they target for this CU.
    // Used to find the target DIE for the IRAttrs
    // referenced by  cuOffInLocalToIRAttr_
    std::map<Dwarf_Unsigned,IRDie*> cuOffInLocalToIRDie_;

    // Refers to IRAttrs which make a CU local reference
    // meaning CLASS_REFERENCE IRFormReference to a cu-local die
    // Once Input dies read in this and cuOffInLocalToIRDie_
    // are used to update the IRAttr itself.
    std::list<OffsetFormEntry> cuOffInLocalToIRFormRef_;

    // The data needed to get the Dwarf_P_Die  set for
    // some class reference instances.
    std::list<ClassReferenceFixupData> classReferenceFixupList_;
};

class IRDInfo {
public:
   IRDInfo() {};
   ~IRDInfo() {};
   IRCUdata &lastCU() { return cudata_.back(); }
   std::list<IRCUdata>& getCUData() {return cudata_; };
private:
   std::list<IRCUdata>  cudata_;
};

