Update GitHub from git://c9x.me/qbe.git

LICENSE

@@ -1,4 +1,4 @@
-© 2015-2016 Quentin Carbonneaux <quentin@c9x.me>
+© 2015-2022 Quentin Carbonneaux <quentin@c9x.me>
 
 Permission is hereby granted, free of charge, to any person obtaining a
 copy of this software and associated documentation files (the "Software"),

Makefile

@@ -1,11 +1,19 @@
 BIN = qbe
-ABI = sysv
 
 V = @
 OBJDIR = obj
 
-SRC = main.c util.c parse.c mem.c ssa.c copy.c fold.c live.c $(ABI).c isel.c spill.c rega.c emit.c
-OBJ = $(SRC:%.c=$(OBJDIR)/%.o)
+SRC      = main.c util.c parse.c cfg.c mem.c ssa.c alias.c load.c copy.c \
+           fold.c live.c spill.c rega.c gas.c
+AMD64SRC = amd64/targ.c amd64/sysv.c amd64/isel.c amd64/emit.c
+ARM64SRC = arm64/targ.c arm64/abi.c arm64/isel.c arm64/emit.c
+RV64SRC  = rv64/targ.c rv64/abi.c rv64/isel.c rv64/emit.c
+SRCALL   = $(SRC) $(AMD64SRC) $(ARM64SRC) $(RV64SRC)
+
+AMD64OBJ = $(AMD64SRC:%.c=$(OBJDIR)/%.o)
+ARM64OBJ = $(ARM64SRC:%.c=$(OBJDIR)/%.o)
+RV64OBJ  = $(RV64SRC:%.c=$(OBJDIR)/%.o)
+OBJ      = $(SRC:%.c=$(OBJDIR)/%.o) $(AMD64OBJ) $(ARM64OBJ) $(RV64OBJ)
 
 CFLAGS += -Wall -Wextra -std=c99 -g -pedantic
 
@@ -19,28 +27,66 @@ $(OBJDIR)/%.o: %.c $(OBJDIR)/timestamp
 
 $(OBJDIR)/timestamp:
 	@mkdir -p $(OBJDIR)
+	@mkdir -p $(OBJDIR)/amd64
+	@mkdir -p $(OBJDIR)/arm64
+	@mkdir -p $(OBJDIR)/rv64
 	@touch $@
 
-$(OBJ): all.h
-obj/main.o: config.h
+$(OBJ): all.h ops.h
+$(AMD64OBJ): amd64/all.h
+$(ARM64OBJ): arm64/all.h
+$(RV64OBJ): rv64/all.h
+$(OBJDIR)/main.o: config.h
 
 config.h:
-	@case `uname` in                                 \
-	*Darwin*)  echo "#define Defaultasm Gasmacho" ;; \
-	*)         echo "#define Defaultasm Gaself" ;;   \
+	@case `uname` in                               \
+	*Darwin*)                                      \
+		echo "#define Defasm Gasmacho";        \
+		echo "#define Deftgt T_amd64_sysv";    \
+		;;                                     \
+	*)                                             \
+		echo "#define Defasm Gaself";          \
+		case `uname -m` in                     \
+		*aarch64*)                             \
+			echo "#define Deftgt T_arm64"; \
+			;;                             \
+		*riscv64*)                             \
+			echo "#define Deftgt T_rv64";  \
+			;;                             \
+		*)                                     \
+			echo "#define Deftgt T_amd64_sysv";\
+			;;                             \
+		esac                                   \
+		;;                                     \
 	esac > $@
 
+install: $(OBJDIR)/$(BIN)
+	mkdir -p "$(DESTDIR)/$(PREFIX)/bin/"
+	cp $< "$(DESTDIR)/$(PREFIX)/bin/"
+
+uninstall:
+	rm -f "$(DESTDIR)/$(PREFIX)/bin/$(BIN)"
+
 clean:
 	rm -fr $(OBJDIR)
 
 clean-gen: clean
 	rm -f config.h
 
 check: $(OBJDIR)/$(BIN)
-	tools/unit.sh all
+	tools/test.sh all
+
+check-arm64: $(OBJDIR)/$(BIN)
+	TARGET=arm64 tools/test.sh all
+
+check-rv64: $(OBJDIR)/$(BIN)
+	TARGET=rv64 tools/test.sh all
+
+src:
+	@echo $(SRCALL)
 
 80:
-	@for F in $(SRC);                          \
+	@for F in $(SRCALL);                       \
 	do                                         \
 		awk "{                             \
 			gsub(/\\t/, \"        \"); \
@@ -49,4 +95,4 @@ check: $(OBJDIR)/$(BIN)
 		}" < $$F;                          \
 	done
 
-.PHONY: clean clean-gen check 80 syndoc
+.PHONY: clean clean-gen check check-arm64 src 80 install uninstall

README

@@ -3,7 +3,10 @@ QBE - Backend Compiler              http://c9x.me/compile/
 doc/    Documentation.
 minic/  An example C frontend for QBE.
 tools/  Miscellaneous tools (testing).
-test/   Unit tests.
+test/   Tests.
+amd64/
+arm64/
+rv64/   Architecture-specific code.
 
 The LICENSE file applies to all files distributed.
 

alias.c

@@ -0,0 +1,169 @@
+#include "all.h"
+
+static void
+getalias(Alias *a, Ref r, Fn *fn)
+{
+	Con *c;
+
+	switch (rtype(r)) {
+	default:
+		die("unreachable");
+	case RTmp:
+		*a = fn->tmp[r.val].alias;
+		if (astack(a->type))
+			a->type = a->slot->type;
+		assert(a->type != ABot);
+		break;
+	case RCon:
+		c = &fn->con[r.val];
+		if (c->type == CAddr) {
+			a->type = ASym;
+			a->label = c->label;
+		} else
+			a->type = ACon;
+		a->offset = c->bits.i;
+		a->slot = 0;
+		break;
+	}
+}
+
+int
+alias(Ref p, int sp, Ref q, int sq, int *delta, Fn *fn)
+{
+	Alias ap, aq;
+	int ovlap;
+
+	getalias(&ap, p, fn);
+	getalias(&aq, q, fn);
+	*delta = ap.offset - aq.offset;
+	ovlap = ap.offset < aq.offset + sq && aq.offset < ap.offset + sp;
+
+	if (astack(ap.type) && astack(aq.type)) {
+		/* if both are offsets of the same
+		 * stack slot, they alias iif they
+		 * overlap */
+		if (req(ap.base, aq.base) && ovlap)
+			return MustAlias;
+		return NoAlias;
+	}
+
+	if (ap.type == ASym && aq.type == ASym) {
+		/* they conservatively alias if the
+		 * symbols are different, or they
+		 * alias for sure if they overlap */
+		if (ap.label != aq.label)
+			return MayAlias;
+		if (ovlap)
+			return MustAlias;
+		return NoAlias;
+	}
+
+	if ((ap.type == ACon && aq.type == ACon)
+	|| (ap.type == aq.type && req(ap.base, aq.base))) {
+		assert(ap.type == ACon || ap.type == AUnk);
+		/* if they have the same base, we
+		 * can rely on the offsets only */
+		if (ovlap)
+			return MustAlias;
+		return NoAlias;
+	}
+
+	/* if one of the two is unknown
+	 * there may be aliasing unless
+	 * the other is provably local */
+	if (ap.type == AUnk && aq.type != ALoc)
+		return MayAlias;
+	if (aq.type == AUnk && ap.type != ALoc)
+		return MayAlias;
+
+	return NoAlias;
+}
+
+int
+escapes(Ref r, Fn *fn)
+{
+	Alias *a;
+
+	if (rtype(r) != RTmp)
+		return 1;
+	a = &fn->tmp[r.val].alias;
+	return !astack(a->type) || a->slot->type == AEsc;
+}
+
+static void
+esc(Ref r, Fn *fn)
+{
+	Alias *a;
+
+	assert(rtype(r) <= RType);
+	if (rtype(r) == RTmp) {
+		a = &fn->tmp[r.val].alias;
+		if (astack(a->type))
+			a->slot->type = AEsc;
+	}
+}
+
+void
+fillalias(Fn *fn)
+{
+	uint n, m;
+	Blk *b;
+	Phi *p;
+	Ins *i;
+	Alias *a, a0, a1;
+
+	for (n=0; n<fn->nblk; ++n) {
+		b = fn->rpo[n];
+		for (p=b->phi; p; p=p->link) {
+			for (m=0; m<p->narg; m++)
+				esc(p->arg[m], fn);
+			assert(rtype(p->to) == RTmp);
+			a = &fn->tmp[p->to.val].alias;
+			assert(a->type == ABot);
+			a->type = AUnk;
+			a->base = p->to;
+			a->offset = 0;
+			a->slot = 0;
+		}
+		for (i=b->ins; i<&b->ins[b->nins]; ++i) {
+			a = 0;
+			if (!req(i->to, R)) {
+				assert(rtype(i->to) == RTmp);
+				a = &fn->tmp[i->to.val].alias;
+				assert(a->type == ABot);
+				if (Oalloc <= i->op && i->op <= Oalloc1) {
+					a->type = ALoc;
+					a->slot = a;
+				} else {
+					a->type = AUnk;
+					a->slot = 0;
+				}
+				a->base = i->to;
+				a->offset = 0;
+			}
+			if (i->op == Ocopy) {
+				assert(a);
+				getalias(a, i->arg[0], fn);
+			}
+			if (i->op == Oadd) {
+				getalias(&a0, i->arg[0], fn);
+				getalias(&a1, i->arg[1], fn);
+				if (a0.type == ACon) {
+					*a = a1;
+					a->offset += a0.offset;
+				}
+				else if (a1.type == ACon) {
+					*a = a0;
+					a->offset += a1.offset;
+				}
+			}
+			if (req(i->to, R) || a->type == AUnk) {
+				if (!isload(i->op))
+					esc(i->arg[0], fn);
+				if (!isstore(i->op))
+					esc(i->arg[1], fn);
+			}
+		}
+		esc(b->jmp.arg, fn);
+	}
+}