Class CompareNodeType

libchigraph/src/LangModule.cpp:463–541

enum class CmpOp { Lt, Gt, Let, Get, Eq, Neq };

struct CompareNodeType : NodeType {
	CompareNodeType(LangModule& mod, DataType ty, CmpOp op)
	    : NodeType(mod), mCompOp(op), mType{ty} {
		makePure();

		std::string opStr = [](CmpOp b) {
			switch (b) {
			case CmpOp::Lt: return "<";
			case CmpOp::Gt: return ">";
			case CmpOp::Let: return "<=";
			case CmpOp::Get: return ">=";
			case CmpOp::Eq: return "==";
			case CmpOp::Neq: return "!=";
			default: return "";
			}
			return "";
		}(mCompOp);

		setName(ty.unqualifiedName() + opStr + ty.unqualifiedName());
		setDescription(ty.unqualifiedName() + opStr + ty.unqualifiedName());

		setDataInputs({{"a", ty}, {"b", ty}});
		setDataOutputs({{"", mod.typeFromName("i1")}});
	}

	Result codegen(
	    size_t /*execInputID*/, const llvm::DebugLoc& nodeLocation,
	    const std::vector<llvm::Value*>& io, llvm::BasicBlock* codegenInto,
	    const std::vector<llvm::BasicBlock*>& outputBlocks,
	    std::unordered_map<std::string, std::shared_ptr<void>>& /*compileCache*/) override {
		assert(io.size() == 3 && codegenInto != nullptr && outputBlocks.size() == 1);

		llvm::IRBuilder<> builder(codegenInto);
		builder.SetCurrentDebugLocation(nodeLocation);

		llvm::Value* result = nullptr;
		if (mType.unqualifiedName() == "i32") {
			result = [&](CmpOp b) -> llvm::Value* {
				switch (b) {
				case CmpOp::Lt: return builder.CreateICmpSLT(io[0], io[1]);
				case CmpOp::Gt: return builder.CreateICmpSGT(io[0], io[1]);
				case CmpOp::Let: return builder.CreateICmpSLE(io[0], io[1]);
				case CmpOp::Get: return builder.CreateICmpSGE(io[0], io[1]);
				case CmpOp::Eq: return builder.CreateICmpEQ(io[0], io[1]);
				case CmpOp::Neq: return builder.CreateICmpNE(io[0], io[1]);
				default: return nullptr;
				}
				return nullptr;
			}(mCompOp);

		} else {
			result = [&](CmpOp b) -> llvm::Value* {
				switch (b) {
				case CmpOp::Lt: return builder.CreateFCmpULT(io[0], io[1]);
				case CmpOp::Gt: return builder.CreateFCmpUGT(io[0], io[1]);
				case CmpOp::Let: return builder.CreateFCmpULE(io[0], io[1]);
				case CmpOp::Get: return builder.CreateFCmpUGE(io[0], io[1]);
				case CmpOp::Eq: return builder.CreateFCmpUEQ(io[0], io[1]);