Subversion Repositories thor

#ifndef _TYPES_H

#define _TYPES_H

// ============================================================================

//        __

//   \\__/ o\    (C) 2012-2018  Robert Finch, Waterloo

//    \  __ /    All rights reserved.

//     \/_//     robfinch<remove>@finitron.ca

//       ||

//

// CC64 - 'C' derived language compiler

//  - 64 bit CPU

//

// This source file is free software: you can redistribute it and/or modify 

// it under the terms of the GNU Lesser General Public License as published 

// by the Free Software Foundation, either version 3 of the License, or     

// (at your option) any later version.                                      

//                                                                          

// This source file 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 this program.  If not, see <http://www.gnu.org/licenses/>.    

//                                                                          

// ============================================================================

//

class Operand;

class ENODE;

class Statement;

class BasicBlock;

class Instruction;

class Var;

class CSE;

class CSETable;

class Operand;

class SYM;

class Function;

class OCODE;

class PeepList;

class CompilerType

{

public:

        static CompilerType *alloc();

};

class MBlk

{

        static MBlk *first;

public:

        MBlk *next;

        static void ReleaseAll();

        static void *alloc(int sz);

};

struct slit {

    struct slit     *next;

    int             label;

    char            *str;

        char                    *nmspace;

};

struct scase {

        int label;

        int64_t val;

};

struct clit {

    struct clit *next;

    int     label;

        int             num;

    scase   *cases;

        char    *nmspace;

};

class C64PException

{

public:

        int errnum;

        int data;

        C64PException(int e, int d) { errnum = e; data = d; };

};

struct typ;

class Statement;

class TYP;

class SYM;

class TypeArray;

class DerivedMethod

{

public:

  int typeno;

  DerivedMethod *next;

  std::string *name;

};

// Class for representing tables. Small footprint.

class TABLE {

public:

        int head, tail;

        int base;

        int owner;

        static SYM *match[100];

        static int matchno;

        TABLE();

        static void CopySymbolTable(TABLE *dst, TABLE *src);

        void insert(SYM* sp);

        SYM *Find(std::string na,bool opt);

        int Find(std::string na);

        int Find(std::string na,__int16,TypeArray *typearray, bool exact);

        int FindRising(std::string na);

        TABLE *GetPtr(int n);

        void SetOwner(int n) { owner = n; };

        int GetHead() { return head; };

        void SetHead(int p) { head = p; };

        void SetTail(int p) { tail = p; };

        void Clear() { head = tail = base = 0; };

        void CopyTo(TABLE *dst) {

                dst->head = head;

                dst->tail = tail;

        };

        void MoveTo(TABLE *dst) {

                CopyTo(dst);

                Clear();

        };

        void SetBase(int b) { base = b; };

};

class PeepList

{

public:

        OCODE *head;

        OCODE *tail;

public:

        void Add(OCODE *cd);

        int Count(OCODE *pos);

        static OCODE *FindLabel(int64_t i);

        static void InsertBefore(OCODE *an, OCODE *cd);

        static void InsertAfter(OCODE *an, OCODE *cd);

        void RemoveCompilerHints2();

        void Remove();

        void loadHex(std::ifstream& ifs);

        void storeHex(txtoStream& ofs);

};

class PeepOpt

{

public:

        static void SetLabelReference();

        static void EliminateUnreferencedLabels();

};

class Function

{

public:

        unsigned int valid : 1;

        unsigned int IsPrototype : 1;

        unsigned int IsTask : 1;

        unsigned int IsInterrupt : 1;

        unsigned int IsNocall : 1;

        unsigned int IsPascal : 1;

        unsigned int IsLeaf : 1;

        unsigned int DoesThrow : 1;

        unsigned int UsesNew : 1;

        unsigned int UsesPredicate : 1;

        unsigned int IsVirtual : 1;

        unsigned int IsInline : 1;

        unsigned int UsesTemps : 1;             // uses temporary registers

        unsigned int UsesStackParms : 1;

        uint8_t NumRegisterVars;

        unsigned __int8 NumParms;

        unsigned __int8 numa;                   // number of stack parameters (autos)

        int stkspace;                                   // stack space used by function

        int argbot;

        int tempbot;

        TABLE proto;

        TABLE params;

        Statement *prolog;

        Statement *epilog;

        unsigned int stksize;

        CSETable *csetbl;

        SYM *sym;

        SYM *parms;                                           // List of parameters associated with symbol

        SYM *nextparm;

        DerivedMethod *derivitives;

        uint64_t mask, rmask;

        uint64_t fpmask, fprmask;

        uint64_t vmask, vrmask;

        BasicBlock *RootBlock;

        BasicBlock *LastBlock;

        BasicBlock *ReturnBlock;

        Var *varlist;

        PeepList pl;                                    // under construction

        OCODE *spAdjust;                                // place where sp adjustment takes place

        OCODE *rcode;

public:

        int GetTempBot() { return (tempbot); };

        void CheckParameterListMatch(Function *s1, Function *s2);

        bool CheckSignatureMatch(Function *a, Function *b) const;

        TypeArray *GetParameterTypes();

        TypeArray *GetProtoTypes();

        void PrintParameterTypes();

        std::string *BuildSignature(int opt = 0);

        Function *FindExactMatch(int mm);

        static Function *FindExactMatch(int mm, std::string name, int rettype, TypeArray *typearray);

        bool HasRegisterParameters();

        bool ProtoTypesMatch(Function *sym);

        bool ProtoTypesMatch(TypeArray *typearray);

        bool ParameterTypesMatch(Function *sym);

        bool ParameterTypesMatch(TypeArray *typearray);

        void BuildParameterList(int *num, int*numa);

        void AddParameters(SYM *list);

        void AddProto(SYM *list);

        void AddProto(TypeArray *);

        void AddDerived();

        void CheckForUndefinedLabels();

        void Summary(Statement *);

        Statement *ParseBody();

        void Init(int nump, int numa);

        int Parse();

        void InsertMethod();

        void SaveGPRegisterVars();

        void SaveFPRegisterVars();

        void SaveRegisterVars();

        void SaveRegisterArguments();

        void RestoreGPRegisterVars();

        void RestoreFPRegisterVars();

        void RestoreRegisterVars();

        void RestoreRegisterArguments();

        void SaveTemporaries(int *sp, int *fsp);

        void RestoreTemporaries(int sp, int fsp);

        void UnlinkStack();

        // Code generation

        void SetupReturnBlock();

        bool GenDefaultCatch();

        void GenReturn(Statement *stmt);

        void Gen();

        void CreateVars();

        void ComputeLiveVars();

        void DumpLiveVars();

};

class SYM {

public:

        int id;

        int parent;

        int next;

        std::string *name;

        std::string *name2;

        std::string *name3;

        std::string *shortname;

        std::string *mangledName;

        char nameext[4];

        char *realname;

        char *stkname;

    __int8 storage_class;

        unsigned int pos : 4;                   // position of the symbol (param, auto or return type)

        // Function attributes

        Function *fi;

        // Auto's are handled by compound statements

        TABLE lsyms;              // local symbols (goto labels)

        unsigned int IsParameter : 1;

        unsigned int IsRegister : 1;

        unsigned int IsAuto : 1;

        unsigned int isConst : 1;

        unsigned int IsKernel : 1;

        unsigned int IsPrivate : 1;

        unsigned int IsUndefined : 1;  // undefined function

        unsigned int ctor : 1;

        unsigned int dtor : 1;

        ENODE *initexp;

        __int16 reg;

    union {

        int64_t i;

        uint64_t u;

        double f;

        uint16_t wa[8];

        char *s;

    } value;

        Float128 f128;

        TYP *tp;

    Statement *stmt;

        static SYM *Copy(SYM *src);

        SYM *Find(std::string name);

        int FindNextExactMatch(int startpos, TypeArray *);

        SYM *FindRisingMatch(bool ignore = false);

        std::string *GetNameHash();

        std::string *BuildSignature(int opt);

        static SYM *GetPtr(int n);

        SYM *GetParentPtr();

        void SetName(std::string nm) {

       name = new std::string(nm);

       name2 = new std::string(nm);

       name3 = new std::string(nm);

           if (mangledName == nullptr)

                   mangledName = new std::string(nm);

        };

        void SetNext(int nxt) { next = nxt; };

        int GetNext() { return next; };

        SYM *GetNextPtr();

        int GetIndex();

        void SetType(TYP *t) {

                if (t == (TYP *)0x500000005) {

                        printf("Press key\n");

                        getchar();

        }

        else

                tp = t;

} ;

        void SetStorageOffset(TYP *head, int nbytes, int al, int ilc, int ztype);

        int AdjustNbytes(int nbytes, int al, int ztype);

};

class TYP {

public:

    e_bt type;

        __int16 typeno;                 // number of the type

        unsigned int val_flag : 1;       /* is it a value type */

        unsigned int isArray : 1;

        unsigned int isUnsigned : 1;

        unsigned int isShort : 1;

        unsigned int isVolatile : 1;

        unsigned int isIO : 1;

        unsigned int isConst : 1;       // const in declaration

        unsigned int isResv : 1;

        __int16 precision;                      // precision of the numeric in bits

        int8_t          bit_width;

        int8_t          bit_offset;

        int8_t          ven;                    // vector element number

        long        size;

        int8_t dimen;

        int numele;                                     // number of elements in array / vector length

        TABLE lst;

        int btp;

        TYP *GetBtp();

        static TYP *GetPtr(int n);

        int GetIndex();

        int GetHash();

        static int GetSize(int num);

        int GetElementSize();

        static int GetBasicType(int num);

        std::string *sname;

        unsigned int alignment;

        static TYP *Make(int bt, int siz);

        static TYP *Copy(TYP *src);

        bool IsScalar();

        bool IsFloatType() const { return (type==bt_quad || type==bt_float || type==bt_double || type==bt_triple); };

        bool IsVectorType() const { return (type==bt_vector); };

        bool IsUnion() const { return (type==bt_union); };

        bool IsStructType() const { return (type==bt_struct || type==bt_class || type==bt_union); };

        bool IsAggregateType() const { return (IsStructType() | isArray); };

        static bool IsSameType(TYP *a, TYP *b, bool exact);

        void put_ty();

        int Alignment();

        int walignment();

        int roundAlignment();

        int roundSize();

        ENODE *BuildEnodeTree();

        // Initialization

        int64_t InitializeArray();

        int64_t InitializeStruct();

        int64_t InitializeUnion();

        int64_t Initialize(int64_t val);

        int64_t Initialize();

        // GC support

        bool FindPointer();

        bool FindPointerInStruct();

        bool IsSkippable();

};

class TypeArray

{

public:

        int types[40];

        __int16 preg[40];

        int length;

        TypeArray();

        void Add(int tp, __int16 regno);

        void Add(TYP *tp, __int16 regno);

        bool IsEmpty();

        bool IsEqual(TypeArray *);

        bool IsLong(int);

        bool IsShort(int);

        bool IsChar(int);

        bool IsByte(int);

        bool IsInt(int);

        void Clear();

        TypeArray *Alloc();

        void Print(txtoStream *);

        void Print();

        std::string *BuildSignature();

};

class ENODE {

public:

        enum e_node nodetype;

        enum e_bt etype;

        long      esize;

        TYP *tp;

        SYM *sym;

        __int8 constflag;

        unsigned int segment : 4;

        unsigned int predreg : 4;

        unsigned int isVolatile : 1;

        unsigned int isIO : 1;

        unsigned int isUnsigned : 1;

        unsigned int isCheckExpr : 1;

        unsigned int isPascal : 1;

        ENODE *vmask;

        __int8 bit_width;

        __int8 bit_offset;

        __int8 scale;

        // The following could be in a value union

        int64_t i;

        double f;

        double f1, f2;

        Float128 f128;

        std::string *sp;

        std::string *msp;

        std::string *udnm;                      // undecorated name

        void *ctor;

        void *dtor;

        ENODE *p[3];

        ENODE *Clone();

        void SetType(TYP *t) { tp = t; if (t) etype = t->type; };

        bool IsPtr() { return (etype == bt_pointer || etype == bt_struct || etype == bt_union || etype == bt_class); };

        bool IsFloatType() { return (etype == bt_double || etype == bt_quad || etype == bt_float || etype == bt_triple); };

        bool IsUnsignedType() { return (etype == bt_ubyte || etype == bt_uchar || etype == bt_ushort || etype == bt_ulong || etype == bt_pointer); };

        bool IsBitfield();

        static bool IsEqualOperand(Operand *a, Operand *b);

        char fsize();

        long GetReferenceSize();

        static bool IsEqual(ENODE *a, ENODE *b);

        // Optimization

        void scanexpr(int duse);

        void repexpr();

        // Code generation

        Operand *GenIndex();

        Operand *GenHook(int flags, int size);

        Operand *GenShift(int flags, int size, int op);

        Operand *GenDivMod(int flags, int size, int op);

        Operand *GenUnary(int flags, int size, int op);

        Operand *GenBinary(int flags, int size, int op);

        Operand *GenAssignShift(int flags, int size, int op);

        Operand *GenAssignAdd(int flags, int size, int op);

        Operand *GenAssignLogic(int flags, int size, int op);

        Operand *GenLand(int flags, int op);

        void PutConstant(txtoStream& ofs, unsigned int lowhigh, unsigned int rshift);

        void PutConstantHex(txtoStream& ofs, unsigned int lowhigh, unsigned int rshift);

        static ENODE *GetConstantHex(std::ifstream& ifs);

};

class Operand : public CompilerType

{

public:

        int num;                                        // number of the operand

        unsigned int mode;

        unsigned int preg : 12;         // primary virtual register number

        unsigned int sreg : 12;         // secondary virtual register number (indexed addressing modes)

        unsigned short int pregs;       // subscripted register number

        unsigned short int sregs;

        unsigned int segment : 4;

        unsigned int defseg : 1;

        unsigned int tempflag : 1;

        unsigned int type : 16;

        char FloatSize;

        unsigned int isUnsigned : 1;

        unsigned int lowhigh : 2;

        unsigned int isVolatile : 1;

        unsigned int isPascal : 1;

        unsigned int rshift : 8;

        unsigned int isPtr : 1;

        short int pdeep;                // previous stack depth on allocation

        short int deep;           /* stack depth on allocation */

        short int deep2;

        ENODE *offset;

        int8_t scale;

        Operand *next;                  // For extended sizes (long)

public:

        Operand *Clone();

        static bool IsEqual(Operand *ap1, Operand *ap2);

        char fpsize();

        void GenZeroExtend(int isize, int osize);

        void GenSignExtend(int isize, int osize, int flags);

        void MakeLegal(int flags, int size);

        // Storage

        void PutAddressMode(txtoStream& ofs);

        void store(txtoStream& fp);

        void storeHex(txtoStream& fp);

        static Operand *loadHex(std::ifstream& fp);

        void load(std::ifstream fp);

};

// Output code structure

class OCODE : public CompilerType

{

public:

        OCODE *fwd, *back, *comment;

        BasicBlock *bb;

        Instruction *insn;

        short opcode;

        short length;

        unsigned int segment : 4;

        unsigned int isVolatile : 1;

        unsigned int isReferenced : 1;  // label is referenced by code

        unsigned int remove : 1;

        unsigned int remove2 : 1;

        unsigned int leader : 1;

        short pregreg;

        short predop;

        int loop_depth;

        Operand *oper1, *oper2, *oper3, *oper4;

        __int16 phiops[100];

public:

        static OCODE *MakeNew();

        static OCODE *Clone(OCODE *p);

        static bool IsEqualOperand(Operand *a, Operand *b) { return (Operand::IsEqual(a, b)); };

        void MarkRemove() { remove = true; };

        void MarkRemove2() { remove2 = true; };

        bool HasTargetReg() const;

        int GetTargetReg(int *rg1, int *rg2) const;

        bool HasSourceReg(int) const;

        //Edge *MakeEdge(OCODE *ip1, OCODE *ip2);

        // Optimizations

        void OptMove();

        void OptRedor();

        static OCODE *loadHex(std::ifstream& ifs);

        void store(txtoStream& ofs);

        void storeHex(txtoStream& ofs);

};

// Control Flow Graph

// For now everything in this class is static and there are no member variables

// to it.

class CFG

{

public:

        static void Create();

        static void CalcDominatorTree();

        static void CalcDominanceFrontiers();

        static void InsertPhiInsns();

        static OCODE *FindLabel(int64_t i) { return (PeepList::FindLabel(i)); };

        static void Rename();

        static void Search(BasicBlock *);

        static void Subscript(Operand *oper);

        static int WhichPred(BasicBlock *x, int y);

};

/*      output code structure   */

/*

OCODE {

        OCODE *fwd, *back, *comment;

        short opcode;

        short length;

        unsigned int isVolatile : 1;

        unsigned int isReferenced : 1;  // label is referenced by code

        unsigned int remove : 1;

        short pregreg;

        short predop;

        Operand *oper1, *oper2, *oper3, *oper4;

};

typedef OCODE OCODE;

*/

class IntStack

{

public:

        int *stk;

        int sp;

        int size;

public:

        static IntStack *MakeNew(int sz) {

                IntStack *s;

                s = (IntStack *)allocx(sizeof(IntStack));

                s->stk = (int *)allocx(sz * sizeof(int));

                s->sp = sz;

                s->size = sz;

                return (s);

        }

        static IntStack *MakeNew() {

                return (MakeNew(1000));

        }

        void push(int v) {

                if (sp > 0) {

                        sp--;

                        stk[sp] = v;

                }

                else

                        throw new C64PException(ERR_STACKFULL, 0);

        };

        int pop() {

                int v = 0;

                if (sp < size) {

                        v = stk[sp];

                        sp++;

                        return (v);

                }

                throw new C64PException(ERR_STACKEMPTY, 0);

        };