Nella/parser scopes

src/backend/analysis/address.cpp

@@ -21,7 +21,7 @@ namespace rat {
 			return n->getType() && n->getType()->isInt() && n->getType()->getIntWidth() == 64;
 		}
 
-		bool termLess(const Pair<const Node*, I64>& a, const Pair<const Node*, I64>& b) {
+		B32 termLess(const Pair<const Node*, I64>& a, const Pair<const Node*, I64>& b) {
 			return a.first->getId() < b.first->getId();
 		}
 

src/backend/ir/text_parser.cpp

@@ -338,7 +338,7 @@ namespace rat {
 			if(lhs.empty() || lhs[0] != 'v' || !allDigits(lhs.substr(1)))
 				return fail("bad result name '" + lhs + "'");
 			errno = 0;
-			unsigned long idv = std::strtoul(lhs.c_str() + 1, nullptr, 10);
+			U64 idv = std::strtoul(lhs.c_str() + 1, nullptr, 10);
 			if(errno == ERANGE || idv > 0xffffffffUL)
 				return fail("result id out of range '" + lhs + "'");
 			pn.id = (U32)idv;
@@ -366,7 +366,7 @@ namespace rat {
 				if(remainder.empty())
 					return fail("constant is missing its value: " + line);
 				errno = 0;
-				char* cend = nullptr;
+				C8* cend = nullptr;
 				pn.cval = (I64)std::strtoll(remainder.c_str(), &cend, 10);
 				if(cend == remainder.c_str() || errno == ERANGE)
 					return fail("bad constant value '" + remainder + "'");
@@ -383,7 +383,7 @@ namespace rat {
 				if(!allDigits(toks[0].substr(1)))
 					return fail("bad proj index '" + toks[0] + "'");
 				errno = 0;
-				unsigned long pj = std::strtoul(toks[0].c_str() + 1, nullptr, 10);
+				U64 pj = std::strtoul(toks[0].c_str() + 1, nullptr, 10);
 				if(errno == ERANGE || pj > 0xffffffffUL)
 					return fail("proj index out of range '" + toks[0] + "'");
 				pn.projIndex = (U32)pj;
@@ -447,7 +447,7 @@ namespace rat {
 				if(laneTok.size() < 2 || laneTok[0] != '#' || !allDigits(laneTok.substr(1)))
 					return fail("malformed lane selector (expected #index): " + line);
 				errno = 0;
-				unsigned long lane = std::strtoul(laneTok.c_str() + 1, nullptr, 10);
+				U64 lane = std::strtoul(laneTok.c_str() + 1, nullptr, 10);
 				if(errno == ERANGE || lane > 0xffffffffUL)
 					return fail("lane selector out of range: " + line);
 				pn.projIndex = (U32)lane; // reuse the proj payload slot for the selector

src/backend/pass/emit/x86/x86_encode.cpp

@@ -559,7 +559,7 @@ namespace rat {
 			U32 instCount = 0;
 			for(const MachineBlock& blk : mf.blocks)
 				instCount += (U32)blk.insts.size();
-			code.reserve((size_t)instCount * 16u + 64u); // cheap upper estimate
+			code.reserve((U64)instCount * 16u + 64u); // cheap upper estimate
 
 			Asm a(code, relocs);
 			reset(mf, fl, a, mf.usedCalleeSaved);

src/backend/pass/emit/x86/x86_lower_ops.cpp

@@ -278,7 +278,7 @@ namespace rat {
 			h ^= x;
 			h *= 1099511628211ull;
 		}
-		std::snprintf(buf, sizeof buf, "__rat_vec_%016llx", (unsigned long long)h);
+		std::snprintf(buf, sizeof buf, "__rat_vec_%016lx", (U64)h);
 		String name(buf);
 		if(!mod->getGlobal(name)) {
 			List<U8> init = bytes;

src/backend/pass/opt/fold.h

@@ -75,7 +75,7 @@ namespace rat {
 		static B32 matchVarConst(Node* n, Opcode want, Node*& base, I64& c);
 	private:
 		List<Node*> work;
-		List<char> queued;
+		List<C8> queued;
 		List<Node*> stack;
 	};
 } // namespace rat

src/backend/pass/opt/gvn.h

@@ -31,7 +31,7 @@ namespace rat {
 		};
 
 		struct GVNKeyHash {
-			size_t operator()(const GVNKey& k) const {
+			U64 operator()(const GVNKey& k) const {
 				U64 h = 1469598103934665603ull;
 				auto mix = [&](U64 v) {
 					h ^= v;
@@ -44,7 +44,7 @@ namespace rat {
 				mix(((U64)k.in1) << 32);
 				if(k.sym)
 					mix(std::hash<String>{}(*k.sym));
-				return (size_t)h;
+				return (U64)h;
 			}
 		};
 

src/backend/pass/opt/sccp.h

@@ -59,7 +59,7 @@ namespace rat {
 		U32 rewrite(Function& fn);
 	private:
 		List<Lattice> values; // lattice for value producing nodes, Top when unset
-		List<char> exec;			// control nodes proven executable
+		List<C8> exec;				// control nodes proven executable
 		List<Node*> flowWork; // executable control nodes to propagate
 		List<Node*> ssaWork;	// value / if nodes to re-evaluate
 	};

src/backend/pass/opt/slp/slp_packer.cpp

@@ -295,7 +295,7 @@ namespace rat {
 	// each broadcast then picks its lane in-register instead of touching memory
 	void slp::Packer::coalesceSplats() {
 		struct Cand {
-			bool operator<(const Cand& o) const {
+			B32 operator<(const Cand& o) const {
 				if(sig != o.sig)
 					return sig < o.sig;
 				return c < o.c;

src/backend/pass/opt/slp/slp_reduce.cpp

@@ -36,7 +36,7 @@ namespace rat {
 		// canonical term order: sort by the first leaf load's refined address so
 		// grouping is robust against source-level reassociation
 		struct Keyed {
-			bool operator<(const Keyed& o) const {
+			B32 operator<(const Keyed& o) const {
 				if(sig != o.sig)
 					return sig < o.sig;
 				return c < o.c;

src/base/core.h

@@ -34,6 +34,7 @@ namespace rat {
 
 	using F32 = float;
 	using F64 = double;
+	using F80 = long double;
 
 	using C8 = char;
 	using B32 = uint32_t;

src/base/test_harness.cpp

@@ -7,12 +7,12 @@
 
 namespace rat {
 	namespace detail {
-		B32 hasSuffix(const String& s, const char* suffix) {
+		B32 hasSuffix(const String& s, const C8* suffix) {
 			String suf = suffix;
 			return s.size() >= suf.size() && s.compare(s.size() - suf.size(), suf.size(), suf) == 0;
 		}
 
-		void collectCases(const String& dir, const char* ext, List<String>& out) {
+		void collectCases(const String& dir, const C8* ext, List<String>& out) {
 			std::error_code ec;
 			List<String> subdirs;
 			List<String> files;
@@ -40,7 +40,7 @@ namespace rat {
 		}
 	} // namespace detail
 
-	I32 runTestSuite(I32 argc, char** argv, const TestSuiteSpec& spec) {
+	I32 runTestSuite(I32 argc, C8** argv, const TestSuiteSpec& spec) {
 		U32 jobs = 1;
 		B32 quiet = false; // -q: only the per-case lines, the caller tallies them
 		List<String> cases;

src/base/test_harness.h

@@ -5,21 +5,21 @@
 
 namespace rat {
 	namespace detail {
-		B32 hasSuffix(const String& s, const char* suffix);
-		void collectCases(const String& dir, const char* ext, List<String>& out);
+		B32 hasSuffix(const String& s, const C8* suffix);
+		void collectCases(const String& dir, const C8* ext, List<String>& out);
 		String findDir(const List<String>& candidates);
 	} // namespace detail
 
 	using CaseRunner = Delegate<B32(const String& path, String& err)>;
 
 	struct TestSuiteSpec {
-		const char* tool;						// program name
-		const char* extension;			// case file suffix
+		const C8* tool;							// program name
+		const C8* extension;				// case file suffix
 		List<String> dirCandidates; // searched when no paths are given
 		CaseRunner run;							// executes a single case
 	};
 
-	I32 runTestSuite(I32 argc, char** argv, const TestSuiteSpec& spec);
+	I32 runTestSuite(I32 argc, C8** argv, const TestSuiteSpec& spec);
 } // namespace rat
 
 #endif

src/compiler/emit/emit.h

@@ -106,8 +106,8 @@ namespace rat::cc {
 		B32 evalConstTyped(const Expr* expr, I64& out, CType& ty);
 		B32 evalConstUnary(ExprOp op, I64 v, CType opTy, I64& out, CType& ty);
 		B32 evalConstBinary(ExprOp op, I64 a, CType aTy, I64 b, CType bTy, I64& out, CType& ty);
-		B32 evalFloatConst(const Expr* expr, long double& out);
-		void encodeFloatBytes(CType dt, long double v, List<U8>& out);
+		B32 evalFloatConst(const Expr* expr, F80& out);
+		void encodeFloatBytes(CType dt, F80 v, List<U8>& out);
 		B32 evalAddrConst(const Expr* expr, String& symbol, I64& addend);
 		B32 addrConstOf(const Expr* lv, String& symbol, I64& addend);
 		String internString(const Expr* strLit);

src/compiler/emit/emit_const.cpp

@@ -158,7 +158,7 @@ namespace rat::cc {
 				return false;
 			CType opTy;
 			if(!evalConstTyped(e->cast.operand, out, opTy)) {
-				long double fv;
+				F80 fv;
 				if(isFloating(ty) || isPointer(ty) || isAggregate(ty) || ty.isVoid())
 					return false;
 				if(!evalFloatConst(e->cast.operand, fv))
@@ -211,12 +211,12 @@ namespace rat::cc {
 		return evalConstTyped(e, out, ty);
 	}
 
-	B32 Emitter::evalFloatConst(const Expr* e, long double& out) {
+	B32 Emitter::evalFloatConst(const Expr* e, F80& out) {
 		if(e->kind == ExprKind::IntLit || e->kind == ExprKind::Cast) {
 			I64 iv;
 			CType it;
 			if(evalConstTyped(e, iv, it) && isInteger(it)) {
-				out = it.isUnsigned() ? (long double)(U64)iv : (long double)iv;
+				out = it.isUnsigned() ? (F80)(U64)iv : (F80)iv;
 				return true;
 			}
 		}
@@ -227,7 +227,7 @@ namespace rat::cc {
 		case ExprKind::Cast:
 			return evalFloatConst(e->cast.operand, out);
 		case ExprKind::Unary: {
-			long double v;
+			F80 v;
 			if(!evalFloatConst(e->unary.operand, v))
 				return false;
 			switch(e->unary.op) {
@@ -242,7 +242,7 @@ namespace rat::cc {
 			}
 		}
 		case ExprKind::Binary: {
-			long double a, b;
+			F80 a, b;
 			if(!evalFloatConst(e->binary.lhs, a) || !evalFloatConst(e->binary.rhs, b))
 				return false;
 			switch(e->binary.op) {
@@ -268,7 +268,7 @@ namespace rat::cc {
 			if(evalConst(e->ternary.cond, ci)) {
 				taken = ci != 0;
 			} else {
-				long double cf;
+				F80 cf;
 				if(!evalFloatConst(e->ternary.cond, cf))
 					return false;
 				taken = cf != 0;

src/compiler/emit/emit_expr.cpp

@@ -241,7 +241,7 @@ namespace rat::cc {
 			CType t;
 			t.base = CType::Base::Float;
 			t.bits = e->floatLit.bits;
-			Node* lit = fn.constFloat(irType(t), (double)e->floatLit.value);
+			Node* lit = fn.constFloat(irType(t), (F64)e->floatLit.value);
 			if(e->floatLit.imaginary) {
 				CType ct = t;
 				ct.set(CType::Complex);

src/compiler/emit/emit_global.cpp

@@ -11,7 +11,7 @@ namespace rat::cc {
 		String name = "__ratcc_str" + std::to_string(strCounter++);
 		List<U8> init;
 		init.reserve(bytes.size() + cw);
-		for(char c : bytes)
+		for(C8 c : bytes)
 			init.push_back((U8)c);
 		for(U32 i = 0; i < cw; ++i)
 			init.push_back(0);
@@ -288,7 +288,7 @@ namespace rat::cc {
 		List<U8> fbytes;
 		if(dinit) {
 			if(isFloating(d.type)) {
-				long double dv = 0;
+				F80 dv = 0;
 				if(!evalFloatConst(dinit, dv)) {
 					fail("initializer for '" + *d.name + "' is not a constant expression");
 					return false;

src/compiler/emit/emit_init_flat.cpp

@@ -156,21 +156,21 @@ namespace rat::cc {
 		return true;
 	}
 
-	void Emitter::encodeFloatBytes(CType dt, long double v, List<U8>& out) {
+	void Emitter::encodeFloatBytes(CType dt, F80 v, List<U8>& out) {
 		if(dt.bits == 32) {
-			float f = (float)v;
+			F32 f = (F32)v;
 			const U8* p = (const U8*)&f;
 			for(U32 i = 0; i < sizeof(f); ++i)
 				out.push_back(p[i]);
 		} else if(dt.bits == 128) {
 			// x86 extended precision
-			long double ld = v;
+			F80 ld = v;
 			const U8* p = (const U8*)&ld;
 			U32 n = byteSize(dt); // 16
 			for(U32 i = 0; i < n; ++i)
 				out.push_back(i < 10 ? p[i] : (U8)0);
 		} else {
-			double d = (double)v;
+			F64 d = (F64)v;
 			const U8* p = (const U8*)&d;
 			for(U32 i = 0; i < sizeof(d); ++i)
 				out.push_back(p[i]);
@@ -185,7 +185,7 @@ namespace rat::cc {
 			return true;
 		U64 bits = 0;
 		if(isFloating(dt)) {
-			long double d = 0;
+			F80 d = 0;
 			if(!emit.evalFloatConst(e, d)) {
 				emit.failNonConstInit();
 				return false;