c.h

来自「基于4个mips核的noc设计」· C头文件 代码 · 共 725 行 · 第 1/2 页

/* $Id: intro.nw,v 2.8 1998/09/15 23:17:18 drh Exp $ */
#include <assert.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#include <string.h>

#define NEW(p,a) ((p) = allocate(sizeof *(p), (a)))
#define NEW0(p,a) memset(NEW((p),(a)), 0, sizeof *(p))
#define isaddrop(op) (specific(op)==ADDRG+P || specific(op)==ADDRL+P \
	|| specific(op)==ADDRF+P)

#define	MAXLINE  512
#define	BUFSIZE 4096

#define istypename(t,tsym) (kind[t] == CHAR \
	|| t == ID && tsym && tsym->sclass == TYPEDEF)
#define sizeop(n) ((n)<<10)
#define generic(op)  ((op)&0x3F0)
#define specific(op) ((op)&0x3FF)
#define opindex(op) (((op)>>4)&0x3F)
#define opkind(op)  ((op)&~0x3F0)
#define opsize(op)  ((op)>>10)
#define optype(op)  ((op)&0xF)
#ifdef __LCC__
#ifndef __STDC__
#define __STDC__
#endif
#endif
#define NELEMS(a) ((int)(sizeof (a)/sizeof ((a)[0])))
#undef roundup
#define roundup(x,n) (((x)+((n)-1))&(~((n)-1)))
#define mkop(op,ty) (specific((op) + ttob(ty)))

#define extend(x,ty) ((x)&(1<<(8*(ty)->size-1)) ? (x)|((~0UL)<<(8*(ty)->size-1)) : (x)&ones(8*(ty)->size))
#define ones(n) ((n)>=8*sizeof (unsigned long) ? ~0UL : ~((~0UL)<<(n)))

#define isqual(t)     ((t)->op >= CONST)
#define unqual(t)     (isqual(t) ? (t)->type : (t))

#define isvolatile(t) ((t)->op == VOLATILE \
                    || (t)->op == CONST+VOLATILE)
#define isconst(t)    ((t)->op == CONST \
                    || (t)->op == CONST+VOLATILE)
#define isarray(t)    (unqual(t)->op == ARRAY)
#define isstruct(t)   (unqual(t)->op == STRUCT \
                    || unqual(t)->op == UNION)
#define isunion(t)    (unqual(t)->op == UNION)
#define isfunc(t)     (unqual(t)->op == FUNCTION)
#define isptr(t)      (unqual(t)->op == POINTER)
#define ischar(t)     ((t)->size == 1 && isint(t))
#define isint(t)      (unqual(t)->op == INT \
                    || unqual(t)->op == UNSIGNED)
#define isfloat(t)    (unqual(t)->op == FLOAT)
#define isarith(t)    (unqual(t)->op <= UNSIGNED)
#define isunsigned(t) (unqual(t)->op == UNSIGNED)
#define isscalar(t)   (unqual(t)->op <= POINTER \
                    || unqual(t)->op == ENUM)
#define isenum(t)     (unqual(t)->op == ENUM)
#define fieldsize(p)  (p)->bitsize
#define fieldright(p) ((p)->lsb - 1)
#define fieldleft(p)  (8*(p)->type->size - \
                        fieldsize(p) - fieldright(p))
#define fieldmask(p)  (~(~(unsigned)0<<fieldsize(p)))
typedef struct node *Node;

typedef struct list *List;

typedef struct code *Code;

typedef struct swtch *Swtch;

typedef struct symbol *Symbol;

typedef struct coord {
	char *file;
	unsigned x, y;
} Coordinate;
typedef struct table *Table;

typedef union value {
	long i;
	unsigned long u;
	long double d;
	void *p;
	void (*g)(void);
} Value;
typedef struct tree *Tree;

typedef struct type *Type;

typedef struct field *Field;

typedef struct {
	unsigned printed:1;
	unsigned marked;
	unsigned short typeno;
	void *xt;
} Xtype;

#include "config.h"
typedef struct metrics {
	unsigned char size, align, outofline;
} Metrics;
typedef struct interface {
	Metrics charmetric;
	Metrics shortmetric;
	Metrics intmetric;
	Metrics longmetric;
	Metrics longlongmetric;
	Metrics floatmetric;
	Metrics doublemetric;
	Metrics longdoublemetric;
	Metrics ptrmetric;
	Metrics structmetric;
	unsigned little_endian;
	int (*mulops_calls)(int);
	unsigned wants_callb;
	unsigned wants_argb;
	unsigned left_to_right;
	unsigned wants_dag;
	unsigned unsigned_char;
void (*address)(Symbol p, Symbol q, long n);
void (*blockbeg)(Env *);
void (*blockend)(Env *);
void (*defaddress)(Symbol);
void (*defconst)  (int suffix, int size, Value v);
void (*defstring)(int n, char *s);
void (*defsymbol)(Symbol);
void (*emit)    (Node);
void (*export)(Symbol);
void (*function)(Symbol, Symbol[], Symbol[], int);
Node (*gen)     (Node);
void (*global)(Symbol);
void (*import)(Symbol);
void (*local)(Symbol);
void (*progbeg)(int argc, char *argv[]);
void (*progend)(void);
void (*segment)(int);
void (*space)(int);
void (*stabblock)(int, int, Symbol*);
void (*stabend)  (Coordinate *, Symbol, Coordinate **, Symbol *, Symbol *);
void (*stabfend) (Symbol, int);
void (*stabinit) (char *, int, char *[]);
void (*stabline) (Coordinate *);
void (*stabsym)  (Symbol);
void (*stabtype) (Symbol);
	Xinterface x;
} Interface;
typedef struct binding {
	char *name;
	Interface *ir;
} Binding;

extern Binding bindings[];
extern Interface *IR;
typedef struct {
	List blockentry;
	List blockexit;
	List entry;
	List exit;
	List returns;
	List points;
	List calls;
	List end;
} Events;

enum {
#define xx(a,b,c,d,e,f,g) a=b,
#define yy(a,b,c,d,e,f,g)
#include "token.h"
	LAST
};
struct node {
	short op;
	short count;
 	Symbol syms[3];
	Node kids[2];
	Node link;
	Xnode x;
};
enum {
	F=FLOAT,
	I=INT,
	U=UNSIGNED,
	P=POINTER,
	V=VOID,
	B=STRUCT
};
#define gop(name,value) name=value<<4,
#define op(name,type,sizes)

enum { gop(CNST,1)
       	op(CNST,F,fdx)
       	op(CNST,I,csilh)
       	op(CNST,P,p)
       	op(CNST,U,csilh)
       gop(ARG,2)
       	op(ARG,B,-)
       	op(ARG,F,fdx)
       	op(ARG,I,ilh)
       	op(ARG,P,p)
       	op(ARG,U,ilh)
       gop(ASGN,3)
       	op(ASGN,B,-)
       	op(ASGN,F,fdx)
       	op(ASGN,I,csilh)
       	op(ASGN,P,p)
       	op(ASGN,U,csilh)
       gop(INDIR,4)
       	op(INDIR,B,-)
       	op(INDIR,F,fdx)
       	op(INDIR,I,csilh)
       	op(INDIR,P,p)
       	op(INDIR,U,csilh)
       gop(CVF,7)
       	op(CVF,F,fdx)
       	op(CVF,I,ilh)
       gop(CVI,8)
       	op(CVI,F,fdx)
       	op(CVI,I,csilh)
       	op(CVI,U,csilhp)
       gop(CVP,9)
       	op(CVP,U,p)
       gop(CVU,11)
       	op(CVU,I,csilh)
       	op(CVU,P,p)
       	op(CVU,U,csilh)
       gop(NEG,12)
       	op(NEG,F,fdx)
       	op(NEG,I,ilh)
       gop(CALL,13)
       	op(CALL,B,-)
       	op(CALL,F,fdx)
       	op(CALL,I,ilh)
       	op(CALL,P,p)
       	op(CALL,U,ilh)
       	op(CALL,V,-)
       gop(RET,15)
       	op(RET,F,fdx)
       	op(RET,I,ilh)
       	op(RET,P,p)
       	op(RET,U,ilh)
       	op(RET,V,-)
       gop(ADDRG,16)
       	op(ADDRG,P,p)
       gop(ADDRF,17)
       	op(ADDRF,P,p)
       gop(ADDRL,18)
       	op(ADDRL,P,p)
       gop(ADD,19)
       	op(ADD,F,fdx)
       	op(ADD,I,ilh)
       	op(ADD,P,p)
       	op(ADD,U,ilhp)
       gop(SUB,20)
       	op(SUB,F,fdx)
       	op(SUB,I,ilh)
       	op(SUB,P,p)
       	op(SUB,U,ilhp)
       gop(LSH,21)
       	op(LSH,I,ilh)
       	op(LSH,U,ilh)
       gop(MOD,22)
       	op(MOD,I,ilh)
       	op(MOD,U,ilh)
       gop(RSH,23)
       	op(RSH,I,ilh)
       	op(RSH,U,ilh)
       gop(BAND,24)
       	op(BAND,I,ilh)
       	op(BAND,U,ilh)
       gop(BCOM,25)
       	op(BCOM,I,ilh)
       	op(BCOM,U,ilh)
       gop(BOR,26)
       	op(BOR,I,ilh)
       	op(BOR,U,ilh)
       gop(BXOR,27)
       	op(BXOR,I,ilh)
       	op(BXOR,U,ilh)
       gop(DIV,28)
       	op(DIV,F,fdx)
       	op(DIV,I,ilh)
       	op(DIV,U,ilh)
       gop(MUL,29)
       	op(MUL,F,fdx)
       	op(MUL,I,ilh)
       	op(MUL,U,ilh)
       gop(EQ,30)
       	op(EQ,F,fdx)
       	op(EQ,I,ilh)
       	op(EQ,U,ilhp)
       gop(GE,31)
       	op(GE,F,fdx)
       	op(GE,I,ilh)
       	op(GE,U,ilhp)
       gop(GT,32)
       	op(GT,F,fdx)
       	op(GT,I,ilh)
       	op(GT,U,ilhp)
       gop(LE,33)
       	op(LE,F,fdx)
       	op(LE,I,ilh)
       	op(LE,U,ilhp)
       gop(LT,34)
       	op(LT,F,fdx)
       	op(LT,I,ilh)
       	op(LT,U,ilhp)
       gop(NE,35)
       	op(NE,F,fdx)
       	op(NE,I,ilh)
       	op(NE,U,ilhp)
       gop(JUMP,36)
       	op(JUMP,V,-)
       gop(LABEL,37)
       	op(LABEL,V,-)
       gop(LOAD,14)
       	op(LOAD,B,-)
       	op(LOAD,F,fdx)
       	op(LOAD,I,csilh)
       	op(LOAD,P,p)
       	op(LOAD,U,csilhp) LASTOP };

#undef gop
#undef op
enum { CODE=1, BSS, DATA, LIT };
enum { PERM=0, FUNC, STMT };
struct list {
	void *x;
	List link;
};

struct code {
	enum { Blockbeg, Blockend, Local, Address, Defpoint,
	       Label,    Start,    Gen,   Jump,    Switch
	} kind;
	Code prev, next;
	union {
		struct {
			int level;
			Symbol *locals;
			Table identifiers, types;
			Env x;
		} block;
		Code begin;
		Symbol var;

		struct {
			Symbol sym;
			Symbol base;
			long offset;
		} addr;
		struct {
			Coordinate src;
			int point;
		} point; 
		Node forest;
		struct {
			Symbol sym;
			Symbol table;
			Symbol deflab;