Nella/clean frontend

src/backend/README.md

@@ -94,7 +94,6 @@ Passes come in three kinds: module `Pass`, `FunctionPass` (run per function), an
 
 ## utility
 - [**verify:**](./pass/verify.h) Edge consistency + per-opcode structural invariants (see [ir](#ir)).
-- [**rename-symbol:**](./pass/opt/rename_symbol.h) Rename a function or global and every reference to it.
 
 Visualization passes (`text-emitter`, `graph-emitter`) are covered in [x86-64 backend](#x86-64-backend).
 

src/backend/rat.h

@@ -16,6 +16,4 @@
 #include "pass/emit/x86/x86_lower.h"
 #include "pass/emit/x86/x86_peephole.h"
 
-#include "pass/opt/rename_symbol.h"
-
 #endif

src/compiler/builtin_headers.cpp

@@ -37,14 +37,15 @@ namespace rat::cc {
 			return ec ? fs::path() : p;
 #endif
 		}
+
+		String includeDirOf(const fs::path& exe) {
+			fs::path h = exe.parent_path() / ".." / "src" / "compiler" / "headers";
+			return h.lexically_normal().generic_string();
+		}
 	} // namespace detail
 
 	const String& builtinIncludeDir() {
-		static const String dir = [] {
-			detail::fs::path exe = detail::selfExePath();
-			detail::fs::path h = exe.parent_path() / ".." / "src" / "compiler" / "headers";
-			return h.lexically_normal().generic_string();
-		}();
+		static const String dir = detail::includeDirOf(detail::selfExePath());
 		return dir;
 	}
 } // namespace rat::cc

src/compiler/builtin_headers.h

@@ -9,6 +9,7 @@ namespace rat::cc {
 	namespace detail {
 		// absolute path of the running executable, cross-platform
 		std::filesystem::path selfExePath();
+		String includeDirOf(const std::filesystem::path& exe);
 	} // namespace detail
 
 	const String& builtinIncludeDir();

src/compiler/compile.cpp

@@ -4,9 +4,6 @@
 
 namespace rat::cc {
 	void composePipeline(PassManager& pm, CompileOptions& opt, std::ostream& out) {
-		if(!opt.renameMain.empty())
-			pm.add<RenameSymbolPass>("main", opt.renameMain);
-
 		Set<String> seen;
 		for(UniquePtr<Pass>& p : opt.optPasses) {
 			String name = p->name();

src/compiler/compile.h

@@ -15,7 +15,6 @@ namespace rat::cc {
 	struct CompileOptions {
 		List<UniquePtr<Pass>> optPasses;
 		List<UniquePtr<MachinePass>> machinePasses; // empty = default x86 pipeline
-		String renameMain;
 	};
 
 	void composePipeline(PassManager& pm, CompileOptions& opt, std::ostream& out);

src/compiler/host.cpp

@@ -5,20 +5,22 @@
 
 namespace rat::cc {
 	namespace detail {
-		TargetTriple& hostTripleStorage() {
-			static TargetTriple triple = [] {
-				TargetTriple t;
+		TargetTriple defaultTriple() {
+			TargetTriple t;
 #if defined(_WIN32)
-				t.os = OS::Windows; // native builds default to the host platform
+			t.os = OS::Windows; // native builds default to the host platform
 #endif
-				const char* env = std::getenv("RATCC_TARGET");
-				if(env && *env) {
-					String err;
-					if(!TargetTriple::parse(env, t, err))
-						std::fprintf(stderr, "ratcc: ignoring RATCC_TARGET: %s\n", err.c_str());
-				}
-				return t;
-			}();
+			const C8* env = std::getenv("RATCC_TARGET");
+			if(env && *env) {
+				String err;
+				if(!TargetTriple::parse(env, t, err))
+					std::fprintf(stderr, "ratcc: ignoring RATCC_TARGET: %s\n", err.c_str());
+			}
+			return t;
+		}
+
+		TargetTriple& hostTripleStorage() {
+			static TargetTriple triple = defaultTriple();
 			return triple;
 		}
 	} // namespace detail

src/compiler/host.h

@@ -7,6 +7,7 @@
 
 namespace rat::cc {
 	namespace detail {
+		TargetTriple defaultTriple();
 		TargetTriple& hostTripleStorage();
 	} // namespace detail
 

src/compiler/lex/char_class.h

@@ -23,43 +23,15 @@ namespace rat::cc {
 		return -1;
 	}
 	inline B32 simpleEscape(C8 e, U8& out) {
-		switch(e) {
-		case 'n':
-			out = '\n';
-			return true;
-		case 't':
-			out = '\t';
-			return true;
-		case 'r':
-			out = '\r';
-			return true;
-		case '\\':
-			out = '\\';
-			return true;
-		case '\'':
-			out = '\'';
-			return true;
-		case '"':
-			out = '"';
-			return true;
-		case 'a':
-			out = '\a';
-			return true;
-		case 'b':
-			out = '\b';
-			return true;
-		case 'f':
-			out = '\f';
-			return true;
-		case 'v':
-			out = '\v';
-			return true;
-		case 'e':
-			out = 27;
-			return true;
-		default:
-			return false;
+		constexpr C8 kFrom[] = {'n', 't', 'r', '\\', '\'', '"', 'a', 'b', 'f', 'v', 'e'};
+		constexpr U8 kTo[] = {'\n', '\t', '\r', '\\', '\'', '"', '\a', '\b', '\f', '\v', 27};
+		for(U32 i = 0; i < sizeof kTo; ++i) {
+			if(kFrom[i] == e) {
+				out = kTo[i];
+				return true;
+			}
 		}
+		return false;
 	}
 } // namespace rat::cc
 

src/compiler/lex/lexer.cpp

@@ -27,7 +27,8 @@ namespace rat::cc {
 									"kTokNames must cover every TokKind");
 
 		B32 validIntSuffix(const C8* s, U32 n) {
-			B32 haveU = false, haveL = false;
+			B32 haveU = false;
+			B32 haveL = false;
 			U32 i = 0;
 			while(i < n) {
 				C8 c = s[i];
@@ -49,7 +50,8 @@ namespace rat::cc {
 		}
 
 		B32 validFloatSuffix(const C8* s, U32 n) {
-			B32 haveSize = false, imag = false;
+			B32 haveSize = false;
+			B32 imag = false;
 			for(U32 i = 0; i < n; ++i) {
 				C8 c = s[i];
 				if(c == 'f' || c == 'F' || c == 'l' || c == 'L') {
@@ -89,6 +91,19 @@ namespace rat::cc {
 			return true;
 		}
 
+		B32 scanExponent(const C8* s, U32 n, U32& i, const C8* missing, String& err) {
+			++i;
+			if(charAt(s, n, i) == '+' || charAt(s, n, i) == '-')
+				++i;
+			if(!isDigit(charAt(s, n, i))) {
+				err = missing;
+				return false;
+			}
+			while(isDigit(charAt(s, n, i)))
+				++i;
+			return true;
+		}
+
 		B32 scanHexNumber(const C8* s, U32 n, U32& i, B32& isFloat, String& err) {
 			i += 2; // "0x"
 			B32 anyDigits = false;
@@ -116,16 +131,7 @@ namespace rat::cc {
 				return false;
 			}
 			isFloat = true;
-			++i;
-			if(charAt(s, n, i) == '+' || charAt(s, n, i) == '-')
-				++i;
-			if(!isDigit(charAt(s, n, i))) {
-				err = "expected digits in binary exponent";
-				return false;
-			}
-			while(isDigit(charAt(s, n, i)))
-				++i;
-			return true;
+			return scanExponent(s, n, i, "expected digits in binary exponent", err);
 		}
 
 		B32 scanDecNumber(const C8* s, U32 n, U32& i, B32& isFloat, String& err) {
@@ -141,16 +147,7 @@ namespace rat::cc {
 			if(c != 'e' && c != 'E')
 				return true;
 			isFloat = true;
-			++i;
-			if(charAt(s, n, i) == '+' || charAt(s, n, i) == '-')
-				++i;
-			if(!isDigit(charAt(s, n, i))) {
-				err = "expected digits in exponent";
-				return false;
-			}
-			while(isDigit(charAt(s, n, i)))
-				++i;
-			return true;
+			return scanExponent(s, n, i, "expected digits in exponent", err);
 		}
 
 		B32 scanNumber(const C8* s, U32 n, U32& i, TokKind& kind, String& err) {

src/compiler/lex/lexer.h

@@ -126,6 +126,7 @@ namespace rat::cc {
 
 		// scanners over one token spelling; advance i, false on error with err set
 		B32 scanSuffix(const C8* s, U32 n, U32& i, B32 isFloat, TokKind& kind, String& err);
+		B32 scanExponent(const C8* s, U32 n, U32& i, const C8* missing, String& err);
 		B32 scanHexNumber(const C8* s, U32 n, U32& i, B32& isFloat, String& err);
 		B32 scanDecNumber(const C8* s, U32 n, U32& i, B32& isFloat, String& err);
 		U32 encodingPrefix(const C8* s, U32 n);