lcc是一款小巧的工業級編譯器，程式碼精簡，程式碼開源，相比gcc更適合編譯器初學者閱讀。

你可以在這裡搞到程式碼：https://github.com/drh/lcc

但是，怎麼說呢，這個程式碼防盜性較強，幾乎沒有註釋，

我在閱讀原始碼中參考了其他前輩關於lcc的文章以及官方推薦書籍《a Retargetable C Compiler---Design and Implementation》

同時為了為了給其他想學習編譯器相關知識的同學提供些幫助，所以我在閱讀原始碼中用中文對原始碼做了較為詳細的註釋。

中間有理解不對的地方，歡迎指正：[email protected]

本文解析編譯器中的一個很重要的模組，它貫穿整個編譯過程，貫穿前端後端。

符號的結構定義在c.h中，如下

struct symbol {
	char *name; //符號的名稱,大多數情況是源程式的符號
	int scope; //符號作用域，常量CONSTANT，標號LABEL，全域性GLOBAL，引數PARAM還是區域性變數LOCAL，在第i層生成的local變數，其scope等於LOCAL+i
	Coordinate src; //符號定義處的位置:檔名，行號和列號
	/*up欄位比較重要，它將符號表中所有符號連結成一個連結串列，最後進入符號表的那個符號為首
	從後向前遍歷該連結串列可以訪問當前作用域內的所有符號，包括被內嵌符號隱藏的符號
	這就提供了除hash方式外另外一個符號表查詢方式。*/
	Symbol up;
	List uses;//如果uses儲存一個Coordiante連結串列，則可表明一個符號的所有使用資訊，也可置null
	int sclass; //符號的擴充套件儲存型別，AUTO/REGISTER/STATIC/EXTERN/TYPEDEF/ENUM，常量和標號不使用該域
	unsigned structarg:1;//結構引數標誌

	unsigned addressed:1;//地址訪問的變數
	unsigned computed:1; //地址樹的標誌.addrtree函式處理
	unsigned temporary:1;//生成的臨時變數標誌
	unsigned generated:1;//生成的符號標誌
	unsigned defined:1; //符號被定義了,避免宣告多次
	Type type;//變數或者常量的型別
	float ref; //標號或變數的引用計數
	/*以上各項對於所有符號表的所有符號通用，常量和標號函式需要使用下面union中的一些域*/
	union {
		 //儲存標號
		struct {
			int label; //全域性分配唯一的標號,這時name儲存標號字串
			Symbol equatedto;
		} l;
		struct {
			unsigned cfields:1;
			unsigned vfields:1;
			Table ftab;		/* omit */
			Field flist;
		} s;
		int value;
		Symbol *idlist;
		struct {
			Value min, max;
		} limits;
		
		//儲存常量的結構
		struct {
			Value v;//儲存實際的常量值
			Symbol loc; //指向符號表的入口
		} c;
		struct {
			Coordinate pt;
			int label;
			int ncalls;
			Symbol *callee;
		} f;
		int seg; //全域性變數或靜態變數給出定義的段
		Symbol alias;
		struct {
			Node cse; //前端生成多次引用公共表示式的臨時變數的DAG節點
			int replace;
			Symbol next;
		} t;
	} u;
	Xsymbol x;//後端使用的符號擴充套件,為變數分配的暫存器，除錯資訊資料等
};
 

#include "c.h"
#include <stdio.h>

static char rcsid[] = "$Id: sym.c,v 1.1 2002/08/28 23:12:47 drh Exp $";

#define equalp(x) v.x == p->sym.u.c.v.x

struct table {
	int level;//符號表作用域
	Table previous;//指向外層(上一層)作用域對應的table
	/**/
	struct entry {
		struct symbol sym;
		struct entry *link;
	} *buckets[256];//指標陣列，指向雜湊連結串列
	Symbol all;//指向當前及其外層作用域中所有符號組成的列表的頭，該列表是通過symbol的up欄位連線起來的
};
#define HASHSIZE NELEMS(((Table)0)->buckets)
static struct table
	cns = { CONSTANTS },
	ext = { GLOBAL },
	ids = { GLOBAL },
	tys = { GLOBAL };
Table constants   = &cns;
Table externals   = &ext;//宣告為extern的標示符
Table identifiers = &ids;//一般標示符
Table globals     = &ids;//上表的一部分
Table types       = &tys;//型別標記
Table labels;
int level = GLOBAL;
static int tempid;
List loci, symbols;

Table newtable(int arena) {
	Table new;

	NEW0(new, arena);
	return new;
}


Table table(Table tp, int level) {
	Table new = newtable(FUNC);//FUNC分配區
	new->previous = tp;
	new->level = level;
	if (tp)
		new->all = tp->all;
	return new;
}
/*scan 一個表tp，並對指定作用域lev的的所有符號執行apply指向的函式的操作*/
void foreach(Table tp, int lev, void (*apply)(Symbol, void *), void *cl) {
	assert(tp);
	while (tp && tp->level > lev)
		tp = tp->previous;//前繼
	if (tp && tp->level == lev) {
		Symbol p;
		Coordinate sav;
		sav = src;
		for (p = tp->all; p && p->scope == lev; p = p->up) {
			src = p->src;
			(*apply)(p, cl);
		}
		src = sav;
	}
}
/*
進入下一層作用域
*/
void enterscope(void) {
	if (++level == LOCAL)
		tempid = 0;
}
/*
退出當前作用域，返回上一層作用域，清理資源
*/
void exitscope(void) {
	rmtypes(level);//types.c,從型別緩衝區刪除在當前作用域定義的帶標記的型別
	if (types->level == level)
		types = types->previous;
	if (identifiers->level == level) {
		if (Aflag >= 2) {
			int n = 0;
			Symbol p;
			for (p = identifiers->all; p && p->scope == level; p = p->up)
				if (++n > 127) {
					warning("more than 127 identifiers declared in a block\n");
					break;
				}
		}
		identifiers = identifiers->previous;
	}
	assert(level >= GLOBAL);
	--level;
}

/*
為給定的name在符號表中分配一個符號並裝進表中
如有需要，還將建立一個新表，返回指向新建符號的指標
*/
Symbol install(const char *name, Table *tpp, int level, int arena) {
	Table tp = *tpp;
	struct entry *p;
	unsigned h = (unsigned long)name&(HASHSIZE-1);//計算hash值

	assert(level == 0 || level >= tp->level);
	if (level > 0 && tp->level < level)
		tp = *tpp = table(tp, level);//新建table
	NEW0(p, arena);//開闢新符號
	p->sym.name = (char *)name;
	p->sym.scope = level;
	p->sym.up = tp->all;
	tp->all = &p->sym;
	p->link = tp->buckets[h];
	tp->buckets[h] = p;
	return &p->sym;
}

Symbol relocate(const char *name, Table src, Table dst) {
	struct entry *p, **q;
	Symbol *r;
	unsigned h = (unsigned long)name&(HASHSIZE-1);

	for (q = &src->buckets[h]; *q; q = &(*q)->link)
		if (name == (*q)->sym.name)
			break;
	assert(*q);
	/*
	 Remove the entry from src's hash chain
	  and from its list of all symbols.
	*/
	p = *q;
	*q = (*q)->link;
	for (r = &src->all; *r && *r != &p->sym; r = &(*r)->up)
		;
	assert(*r == &p->sym);
	*r = p->sym.up;
	/*
	 Insert the entry into dst's hash chain
	  and into its list of all symbols.
	  Return the symbol-table entry.
	*/
	p->link = dst->buckets[h];
	dst->buckets[h] = p;
	p->sym.up = dst->all;
	dst->all = &p->sym;
	return &p->sym;
}
/*通過name欄位在tp中查詢對應的符號，
  如果存在，返回指向符號的指標，
  不存在，返回NULL
*/
Symbol lookup(const char *name, Table tp) {
	struct entry *p;
	unsigned h = (unsigned long)name&(HASHSIZE-1);

	assert(tp);
	do
		for (p = tp->buckets[h]; p; p = p->link)
			if (name == p->sym.name)
				return &p->sym;
	while ((tp = tp->previous) != NULL);
	return NULL;
}
int genlabel(int n) {
	static int label = 1;

	label += n;
	return label - n;
}

/*查詢標號，
如果有相應編號，則返回指向符號的指標，
如果沒有，則新建一個標號
標號特有的*/
Symbol findlabel(int lab) {
	struct entry *p;
	unsigned h = lab&(HASHSIZE-1);

	for (p = labels->buckets[h]; p; p = p->link)
		if (lab == p->sym.u.l.label)
			return &p->sym;/*找到，返回地址*/
	NEW0(p, FUNC);/*沒有，新建*/
	p->sym.name = stringd(lab);
	p->sym.scope = LABELS;
	p->sym.up = labels->all;
	labels->all = &p->sym;/*更新all到新建sym，記住，all總是指向up連結串列的最後一個點*/
	p->link = labels->buckets[h];
	labels->buckets[h] = p;
	p->sym.generated = 1;
	p->sym.u.l.label = lab;
	(*IR->defsymbol)(&p->sym);//告知後端
	return &p->sym;
}

/*在常量表中查詢給定型別和值的常量，如需要，在表中增加常量v*/
Symbol constant(Type ty, Value v) {
	struct entry *p;
	unsigned h = v.u&(HASHSIZE-1);
	static union { int x; char endian; } little = { 1 };

	ty = unqual(ty);//去掉const和volatile
	for (p = constants->buckets[h]; p; p = p->link)//遍歷constant符號表
		if (eqtype(ty, p->sym.type, 1))//型別是否相等
			switch (ty->op) {
			case INT:      if (equalp(i)) return &p->sym; break;
			case UNSIGNED: if (equalp(u)) return &p->sym; break;
			case FLOAT:
				if (v.d == 0.0) {
					float z1 = v.d, z2 = p->sym.u.c.v.d;
					char *b1 = (char *)&z1, *b2 = (char *)&z2;
					if (z1 == z2
					&& (!little.endian && b1[0] == b2[0]
					||   little.endian && b1[sizeof (z1)-1] == b2[sizeof (z2)-1]))
						return &p->sym;
				} else if (equalp(d))
					return &p->sym;
				break;
			case FUNCTION: if (equalp(g)) return &p->sym; break;
			case ARRAY:
			case POINTER:  if (equalp(p)) return &p->sym; break;
			default: assert(0);
			}
			
	NEW0(p, PERM);
	p->sym.name = vtoa(ty, v);
	p->sym.scope = CONSTANTS;
	p->sym.type = ty;
	p->sym.sclass = STATIC;
	p->sym.u.c.v = v;
	p->link = constants->buckets[h];
	p->sym.up = constants->all;
	constants->all = &p->sym;
	constants->buckets[h] = p;
	if (ty->u.sym && !ty->u.sym->addressed)
		(*IR->defsymbol)(&p->sym);//告知後端
	p->sym.defined = 1;
	return &p->sym;
}

/*封裝整形常量的建立和查詢*/
Symbol intconst(int n) {
	Value v;

	v.i = n;
	return constant(inttype, v);
}

/*依據入參儲存型別scls，型別ty，作用域lev，產生一個標示符並初始化*/
Symbol genident(int scls, Type ty, int lev) {
	Symbol p;

	NEW0(p, lev >= LOCAL ? FUNC : PERM);
	p->name = stringd(genlabel(1));
	p->scope = lev;
	p->sclass = scls;
	p->type = ty;
	p->generated = 1;
	if (lev == GLOBAL)//引數和區域性變數在其他地方告知後端
		(*IR->defsymbol)(p);
	return p;
}

Symbol temporary(int scls, Type ty) {
	Symbol p;

	NEW0(p, FUNC);
	p->name = stringd(++tempid);
	p->scope = level < LOCAL ? LOCAL : level;
	p->sclass = scls;
	p->type = ty;
	p->temporary = 1;//根上面這個函式比，就這處差異
	p->generated = 1;
	return p;
}

Symbol newtemp(int sclass, int tc, int size) {
	//通過btot將型別字尾tc和size對映成type傳入temporary
	Symbol p = temporary(sclass, btot(tc, size));

	(*IR->local)(p);
	p->defined = 1;
	return p;
}
//返回指向所有符號的連結串列尾節點的all
Symbol allsymbols(Table tp) {
	return tp->all;
}

//新增新節點到loci和symbols
void locus(Table tp, Coordinate *cp) {
	loci    = append(cp, loci);
	symbols = append(allsymbols(tp), symbols);
}

void use(Symbol p, Coordinate src) {
	Coordinate *cp;

	NEW(cp, PERM);
	*cp = src;
	p->uses = append(cp, p->uses);
}

/* findtype - find type ty in identifiers */
Symbol findtype(Type ty) {
	Table tp = identifiers;
	int i;
	struct entry *p;

	assert(tp);
	do
		for (i = 0; i < HASHSIZE; i++)
			for (p = tp->buckets[i]; p; p = p->link)
				if (p->sym.type == ty && p->sym.sclass == TYPEDEF)
					return &p->sym;
	while ((tp = tp->previous) != NULL);
	return NULL;
}

/* mkstr - make a string constant */
Symbol mkstr(char *str) {
	Value v;
	Symbol p;

	v.p = str;
	p = constant(array(chartype, strlen(v.p) + 1, 0), v);
	if (p->u.c.loc == NULL)
		p->u.c.loc = genident(STATIC, p->type, GLOBAL);
	return p;
}

/* mksymbol - make a symbol for name, install in &globals if sclass==EXTERN */
Symbol mksymbol(int sclass, const char *name, Type ty) {
	Symbol p;

	if (sclass == EXTERN)
		p = install(string(name), &globals, GLOBAL, PERM);
	else {
		NEW0(p, PERM);
		p->name = string(name);
		p->scope = GLOBAL;
	}
	p->sclass = sclass;
	p->type = ty;
	(*IR->defsymbol)(p);
	p->defined = 1;
	return p;
}

/* vtoa - return string for the constant v of type ty */
char *vtoa(Type ty, Value v) {
	char buf[50];//這個buf是個unused variable，根據github記錄，hanson已經將之刪除
<span style="white-space:pre">	</span>//fix log:  https://github.com/drh/lcc/commit/3b3f01b4103cd7b519ae84bd1122c9b03233e687
	ty = unqual(ty);
	switch (ty->op) {
	case INT:      return stringd(v.i);
	case UNSIGNED: return stringf((v.u&~0x7FFF) ? "0x%X" : "%U", v.u);
	case FLOAT:    return stringf("%g", (double)v.d);
	case ARRAY:
		if (ty->type == chartype || ty->type == signedchar
		||  ty->type == unsignedchar)
			return v.p;
		return stringf("%p", v.p);
	case POINTER:  return stringf("%p", v.p);
	case FUNCTION: return stringf("%p", v.g);
	}
	assert(0); return NULL;
}