Merge pull request #56 from PipeRift/feature/ir-generation

Generate IR statements

Author: muit

Libs/Backends/LLVM/Include/LLVMBackend/Components/CIRFunction.h

@@ -1,6 +1,7 @@
 // Copyright 2015-2022 Piperift - All rights reserved
 #pragma once
 
+#include <AST/Types.h>
 #include <llvm/IR/Function.h>
 #include <Types/Struct.h>
 
@@ -13,7 +14,10 @@ namespace Rift
 
 		llvm::Function* instance = nullptr;
 
+		TArray<llvm::Value*> inputs;
+		TArray<AST::Id> inputIds;
 
-		CIRFunction(llvm::Function* instance) : instance(instance) {}
+
+		CIRFunction() {}
 	};
 }    // namespace Rift

Libs/Backends/LLVM/Src/LLVMBackend/IRGeneration.cpp

@@ -41,6 +41,17 @@ namespace Rift::Compiler::LLVM
 	using namespace llvm;
 
 
+	using BlockAccessRef = TAccessRef<CStmtOutput, CStmtOutputs, CStmtIf, CExprCallId, CIRFunction>;
+
+	// Forward declarations
+	void AddStmtBlock(Context& context, LLVMContext& llvm, IRBuilder<>& builder,
+	    BlockAccessRef access, AST::Id firstStmtId, BasicBlock* block, const CIRFunction& function);
+	BasicBlock* AddIf(Context& context, LLVMContext& llvm, IRBuilder<>& builder,
+	    BlockAccessRef access, AST::Id id, const CIRFunction& function);
+	void AddCall(Context& context, LLVMContext& llvm, IRBuilder<>& builder, const CExprCallId& call,
+	    BlockAccessRef access);
+
+
 	void BindNativeTypes(LLVMContext& llvm, TAccessRef<CType, TWrite<CIRType>> access)
 	{
 		const auto& nativeTypes = access.GetAST().GetNativeTypes();
@@ -104,38 +115,6 @@ namespace Rift::Compiler::LLVM
 		}
 	}
 
-	void DefineFunctions(Context& context, LLVMContext& llvm, IRBuilder<>& builder,
-	    TAccessRef<CIRFunction, CStmtOutputs, CExprCall, CStmtIf, CStmtReturn, CIRInstruction>
-	        access,
-	    TSpan<AST::Id> ids, Module& irModule)
-	{
-		ZoneScoped;
-		for (AST::Id id : ids)
-		{
-			const auto& irFunction = access.Get<const CIRFunction>(id);
-			BasicBlock* bb         = BasicBlock::Create(llvm, "entry", irFunction.instance);
-			builder.SetInsertPoint(bb);
-
-			TArray<AST::Id> stmtIds{id};
-
-			// Scan function statement chain and cache it
-			TArray<AST::Id> stmtsToCheck{id};
-			TArray<AST::Id> lastStmtOutputs;
-			while (!stmtsToCheck.IsEmpty())
-			{
-				AST::Statements::GetConnectedToOutputs(access, stmtsToCheck, lastStmtOutputs);
-				lastStmtOutputs.RemoveIf([&access](AST::Id id) {
-					return !access.IsValid(id);
-				});
-				stmtIds.Append(lastStmtOutputs);
-				stmtsToCheck = lastStmtOutputs;
-				lastStmtOutputs.Empty(false);
-			}
-
-			verifyFunction(*irFunction.instance);
-		}
-	}
-
 	void DeclareFunctions(Context& context, LLVMContext& llvm, IRBuilder<>& builder,
 	    TAccessRef<TWrite<CIRFunction>, CIdentifier, CExprType, CExprOutputs, CIRType, CParent>
 	        access,
@@ -146,9 +125,9 @@ namespace Rift::Compiler::LLVM
 		TArray<llvm::Type*> inputTypes;
 		for (AST::Id id : ids)
 		{
+			auto& functionComp = access.Add<CIRFunction>(id);
+
 			// Gather arguments
-			inputIds.Empty(false);
-			inputTypes.Empty(false);
 			AST::Hierarchy::GetChildren(access, id, inputIds);
 			AST::RemoveIfNot<CExprOutputs>(access, inputIds);
 			AST::RemoveIfNot<CExprType>(access, inputIds);
@@ -175,59 +154,116 @@ namespace Rift::Compiler::LLVM
 			// Create function
 			const CIdentifier& ident = access.Get<const CIdentifier>(id);
 			auto* functionType = FunctionType::get(builder.getVoidTy(), ToLLVM(inputTypes), false);
-			auto* function     = Function::Create(
-			        functionType, Function::ExternalLinkage, ToLLVM(ident.name), &irModule);
+			functionComp.instance = Function::Create(
+			    functionType, Function::ExternalLinkage, ToLLVM(ident.name), &irModule);
 
 			// Set argument names
-			i32 i = 0;
-			for (auto& arg : function->args())
+			i32 i            = 0;
+			const auto& args = functionComp.instance->args();
+			for (auto& arg : args)
 			{
 				Name name = Names::GetName(access, inputIds[i++]);
 				arg.setName(ToLLVM(name));
 			}
-			access.Add<CIRFunction>(id, {function});
+
+			// Cache final inputs
+			functionComp.inputs   = {args.begin(), args.end()};
+			functionComp.inputIds = inputIds;
+			inputIds.Empty(false);
+			inputTypes.Empty(false);
 		}
 	}
 
-	void AddExprCalls(Context& context, LLVMContext& llvm, IRBuilder<>& builder,
-	    TAccessRef<CExprCallId, CIRFunction, TWrite<CIRInstruction>> access)
+	void AddStmtBlock(Context& context, LLVMContext& llvm, IRBuilder<>& builder,
+	    BlockAccessRef access, AST::Id firstStmtId, BasicBlock* block, const CIRFunction& function)
 	{
 		ZoneScoped;
-		for (AST::Id id : AST::ListAll<CExprCallId>(access))
+		builder.SetInsertPoint(block);
+
+		AST::Id splitId = AST::NoId;
+		TArray<AST::Id> stmtIds;
+		AST::Statements::GetChain(access, firstStmtId, stmtIds, splitId);
+
+		for (AST::Id id : stmtIds)
 		{
-			const AST::Id functionId = access.Get<const CExprCallId>(id).functionId;
-			if (!access.IsValid(functionId))
+			if (const auto* call = access.TryGet<const CExprCallId>(id))
 			{
-				context.AddError("Call to an unknown function");
-				continue;
+				AddCall(context, llvm, builder, *call, access);
 			}
-			const auto* function = access.TryGet<const CIRFunction>(functionId);
-			if (!Ensure(function))
+		}
+
+		if (splitId != AST::NoId)
+		{
+			if (access.Has<const CStmtIf>(splitId))
 			{
-				context.AddError("Call to an invalid function");
-				continue;
+				AddIf(context, llvm, builder, access, splitId, function);
 			}
+		}
+		// TODO: Resolve continuation block and generate it
+	}
+
+	BasicBlock* AddIf(Context& context, LLVMContext& llvm, IRBuilder<>& builder,
+	    BlockAccessRef access, AST::Id id, const CIRFunction& function)
+	{
+		const auto& outputs      = access.Get<const CStmtOutputs>(id);
+		const auto& connectedIds = outputs.linkInputNodes;
+		Check(connectedIds.Size() == 2);
 
-			// TODO: Make sure arguments match
-			// if (CalleeF->arg_size() != Args.size())
-			//	context.AddError("Incorrect number of arguments provided");
+		// Temporarily using value false until we have expressions
+		Value* condV = ConstantInt::get(llvm, APInt(1, false, true));
 
-			TArray<Value*> args;
-			access.Add<CIRInstruction>(
-			    id, {CallInst::Create(function->instance, ToLLVM(args), "calltmp")});
+		BasicBlock* thenBlock = BasicBlock::Create(llvm, "then");
+		BasicBlock* elseBlock = BasicBlock::Create(llvm, "else");
+		BasicBlock* contBlock = BasicBlock::Create(llvm, "continue");
+		builder.CreateCondBr(condV, thenBlock, elseBlock);
+
+		function.instance->getBasicBlockList().push_back(thenBlock);
+		AddStmtBlock(context, llvm, builder, access, connectedIds[0], thenBlock, function);
+		builder.CreateBr(contBlock);
+
+		function.instance->getBasicBlockList().push_back(elseBlock);
+		AddStmtBlock(context, llvm, builder, access, connectedIds[1], elseBlock, function);
+		builder.CreateBr(contBlock);
+
+		function.instance->getBasicBlockList().push_back(contBlock);
+		return contBlock;
+	}
+
+	void AddCall(Context& context, LLVMContext& llvm, IRBuilder<>& builder, const CExprCallId& call,
+	    BlockAccessRef access)
+	{
+		const AST::Id functionId = call.functionId;
+		if (!access.IsValid(functionId))
+		{
+			context.AddError("Call to an unknown function");
+			return;
 		}
+		const auto* function = access.TryGet<const CIRFunction>(functionId);
+		if (!Ensure(function))
+		{
+			context.AddError("Call to an invalid function");
+			return;
+		}
+
+		TArray<Value*> args;
+		// TODO: Pass arguments
+		builder.CreateCall(function->instance, ToLLVM(args));
 	}
 
-	Value* AddIf(TAccessRef<CStmtIf> access, AST::Id id, AST::Id valueId)
+	void DefineFunctions(Context& context, LLVMContext& llvm, IRBuilder<>& builder,
+	    BlockAccessRef access, TSpan<AST::Id> ids, Module& irModule)
 	{
-		// Value* condV = value;
-		// Convert condition to a bool by comparing non-equal to 0.0.
-		// condV = builder.CreateFCmpONE(condV, ConstantFP::get(llvm, APFloat(0.0)), "ifcond");
-		// BasicBlock* thenBlock  = BasicBlock::Create(llvm, "then", function);
-		// BasicBlock* elseBlock  = BasicBlock::Create(llvm, "else");
-		// BasicBlock* mergeBlock = BasicBlock::Create(llvm, "ifcont");
-		// builder.CreateCondBr(condV, thenBlock, elseBlock);
-		return nullptr;
+		ZoneScoped;
+		for (AST::Id id : ids)
+		{
+			const auto& irFunction = access.Get<const CIRFunction>(id);
+			BasicBlock* block      = BasicBlock::Create(llvm, "entry", irFunction.instance);
+
+			const auto& output = access.Get<const CStmtOutput>(id);
+			AddStmtBlock(context, llvm, builder, access, output.linkInputNode, block, irFunction);
+
+			verifyFunction(*irFunction.instance);
+		}
 	}
 
 
@@ -250,7 +286,7 @@ namespace Rift::Compiler::LLVM
 		for (AST::Id id : AST::ListAll<CLiteralBool>(access))
 		{
 			const auto& boolean = access.Get<const CLiteralBool>(id);
-			Value* value        = ConstantInt::get(llvm, APInt(8, boolean.value, true));
+			Value* value        = ConstantInt::get(llvm, APInt(1, boolean.value, true));
 			access.Add<CIRValue>(id, value);
 		}
 		for (AST::Id id : AST::ListAll<CLiteralIntegral>(access))
@@ -296,7 +332,6 @@ namespace Rift::Compiler::LLVM
 		AST::RemoveIfNot<CDeclStruct>(ast, structIds);
 		AST::RemoveIfNot<CDeclClass>(ast, classIds);
 
-
 		DeclareStructs(llvm, ast, structIds, false);
 		DeclareStructs(llvm, ast, classIds, true);    // Declare classes
 
@@ -305,9 +340,6 @@ namespace Rift::Compiler::LLVM
 		AST::RemoveIfNot<CDeclFunction>(ast, functionIds);
 		DeclareFunctions(context, llvm, builder, ast, functionIds, irModule);
 
-		// Generate expressions
-		AddExprCalls(context, llvm, builder, ast);
-
 		DefineStructs(context, llvm, ast, structIds, false);
 		DefineStructs(context, llvm, ast, classIds, true);    // Define classes
 		DefineFunctions(context, llvm, builder, ast, functionIds, irModule);

Libs/Core

@@ -2,8 +2,20 @@
 
 #pragma once
 
-#include "AST/Tree.h"
-
+#include <AST/Components/CDeclClass.h>
+#include <AST/Components/CDeclFunction.h>
+#include <AST/Components/CDeclFunctionLibrary.h>
+#include <AST/Components/CDeclNative.h>
+#include <AST/Components/CDeclStruct.h>
+#include <AST/Components/CDeclVariable.h>
+#include <AST/Components/CExprInput.h>
+#include <AST/Components/CExprOutputs.h>
+#include <AST/Components/CExprType.h>
+#include <AST/Components/CIdentifier.h>
+#include <AST/Components/CType.h>
+#include <AST/Filtering.h>
+#include <AST/Tree.h>
+#include <AST/Utils/TransactionUtils.h>
 #include <Strings/StringView.h>
 
 
@@ -17,13 +29,18 @@ namespace Rift
 		None      = 0,
 		HideValue = 1 << 0
 	};
+
+	using TVariableAccessRef = TAccessRef<TWrite<CDeclVariable>, TWrite<CIdentifier>, CType,
+	    CDeclNative, CDeclStruct, CDeclClass, CParent>;
+
 	void DrawField(AST::Tree& ast, CTypeEditor& editor, AST::Id functionId, AST::Id fieldId,
 	    DrawFieldFlags flags = DrawFieldFlags::None);
 
-	void DrawVariable(AST::Tree& ast, CTypeEditor& editor, AST::Id variableId);
+	void DrawVariable(TVariableAccessRef access, CTypeEditor& editor, AST::Id variableId);
 	void DrawFunction(AST::Tree& ast, CTypeEditor& editor, AST::Id functionId);
 
-	void DrawVariables(AST::Tree& ast, CTypeEditor& editor, AST::Id typeId);
+	void DrawVariables(TVariableAccessRef access, TransactionAccess transAccess,
+	    CTypeEditor& editor, AST::Id typeId);
 	void DrawFunctions(AST::Tree& ast, CTypeEditor& editor, AST::Id typeId);
 
 	void DrawProperties(AST::Tree& ast, AST::Id typeId);

Libs/Editor/Include/Utils/Properties.h

@@ -2,13 +2,19 @@
 
 #pragma once
 
+#include <AST/Components/CDeclClass.h>
+#include <AST/Components/CDeclNative.h>
+#include <AST/Components/CDeclStruct.h>
+#include <AST/Components/CType.h>
+#include <AST/Filtering.h>
 #include <AST/Tree.h>
 #include <Strings/StringView.h>
 
 
 namespace Rift::Editor
 {
-	bool TypeCombo(AST::Tree& ast, StringView label, AST::Id& selectedTypeId);
+	bool TypeCombo(TAccessRef<CType, CDeclNative, CDeclStruct, CDeclClass> access, StringView label,
+	    AST::Id& selectedTypeId);
 
 	bool InputLiteralValue(AST::Tree& ast, StringView label, AST::Id literalId);
 }    // namespace Rift::Editor