Support LLVM backend

.clang-tidy

@@ -8,13 +8,21 @@
 #
 # -cppcoreguidelines-explicit-virtual-functions:
 #   It's an alias of "modernize-use-override".
+#
+# -bugprone-unchecked-optional-access:
+#   Clang-tidy will crash due to unknown reasons.
+#
+# -bugprone-easily-swappable-parameters
+#   Nothing we can do about it.
 
 # Warnings are easily be overlooked when they are not treated as errors.
 WarningsAsErrors: "*"
 
 Checks: >
   -*,
   bugprone-*,
+  -bugprone-unchecked-optional-access,
+  -bugprone-easily-swappable-parameters,
   performance-*,
   clang-analyzer-*,
   cppcoreguidelines-*,

.github/workflows/ci.yml

@@ -50,6 +50,12 @@ jobs:
     steps:
       - uses: actions/checkout@v3
       - uses: actions/setup-python@v3
+      - name: Install LLVM
+        run: |
+          sudo add-apt-repository -y 'deb http://apt.llvm.org/jammy/ llvm-toolchain-jammy-18 main'
+          wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | sudo apt-key add -
+          sudo apt-get update
+          sudo apt-get install -q -y llvm-18 lld-18 llvm-18-runtime
       - name: Install QBE
         run: scripts/install-qbe.sh
       - name: Install cxxopts

.gitignore

@@ -47,6 +47,9 @@ lex.yy.*
 # QBE IR files
 *.ssa
 
+# LLVM IR files
+*.ll
+
 # Python environments
 .env
 .venv

Makefile

@@ -2,9 +2,9 @@ TARGET := vitaminc
 CXX := g++
 CC = $(CXX)
 CLANG_TIDY ?= clang-tidy
-CXXFLAGS = -g3 -std=c++17 -Wall -MMD -Iinclude -Werror
+CXXFLAGS = -g3 -std=c++17 -Wall -MMD -Iinclude -I$(shell llvm-config-18 --includedir) -Werror
 CFLAGS = $(CXXFLAGS)
-LDLIBS = -lfmt
+LDLIBS = -lfmt $(shell llvm-config-18 --libs core)
 LEX = lex
 # C++ features are used, yacc doesn't suffice
 YACC = bison
@@ -87,7 +87,7 @@ coverage-report: coverage
 	@echo "Open $(COVERAGE_DIR)/index.html in your browser to view the coverage report."
 
 clean:
-	$(RM) -r *.s *.o lex.yy.* y.tab.* *.output *.ssa *.out $(TARGET) $(OBJS) $(DEPS) \
+	$(RM) -r *.s *.o lex.yy.* y.tab.* *.output *.ssa *.out *.ll $(TARGET) $(OBJS) $(DEPS) \
 		$(OBJS:.o=.gcda) $(OBJS:.o=.gcno) *.gcov $(COVERAGE_DIR)
 	cd test/ && $(MAKE) clean
 

README.md

@@ -9,15 +9,16 @@ VitaminC 🍋 is an educational C compiler frontend written in C++. As a fronten
 > [!WARNING]
 > This project is still under development. Many features are not yet implemented. Currently, we do not support preprocessor directives, and only the `int` type and its pointer, as well as object types, are supported.
 
-The main goal of this project is to demonstrate how a compiler frontend works with [the LLVM compiler infrastructure](https://llvm.org/) and generates LLVM IR. However, we are not yet there. Currently, we generate [QBE](https://c9x.me/compile/) IR manually.
+The main goal of this project is to demonstrate how a compiler frontend works with [the LLVM compiler infrastructure](https://llvm.org/) and generates LLVM IR. Currently, this compiler can generate [QBE](https://c9x.me/compile/) IR and [LLVM](https://llvm.org/docs/LangRef.html) IR.
 
 We are not aiming to be a fully compliant C compiler, although we strive to be as compliant as possible with C89 and support common C99 features.
 
 ## Prerequisites
 
 - A C++ compiler that supports C++17.
 - [GNU Make](https://www.gnu.org/software/make/): for building the project.
-- [QBE](https://c9x.me/compile/releases.html): for compiling the QBE IR down to assembly.
+- [QBE](https://c9x.me/compile/releases.html): for compiling QBE IR to assembly.
+- [LLVM-18](https://releases.llvm.org/): for generating LLVM IR and compiling it to assembly.
 - [cxxopts](https://github.com/jarro2783/cxxopts): for command-line argument parsing.
 - [fmt](https://fmt.dev/latest/index.html): for modern C++ formatting.
 - (test-only) [turnt](https://github.com/cucapra/turnt): for snapshot testing.
@@ -49,10 +50,10 @@ A simple C compiler.
 Usage:
   ./vitaminc [options] file
 
-  -o, --output <file>  Write output to <file> (default: a.out)
-  -d, --dump           Dump the abstract syntax tree
-  -t, --target [qbe]   Specify target IR (default: qbe)
-  -h, --help           Display available options
+  -o, --output <file>      Write output to <file> (default: a.out)
+  -d, --dump               Dump the abstract syntax tree
+  -t, --target [qbe|llvm]  Specify target IR (default: qbe)
+  -h, --help               Display available options
 ```
 
 ## License

include/llvm/util.hpp

@@ -0,0 +1,60 @@
+#ifndef LLVM_UTIL_HPP_
+#define LLVM_UTIL_HPP_
+
+#include <llvm/IR/BasicBlock.h>
+#include <llvm/IR/Function.h>
+#include <llvm/IR/IRBuilder.h>
+#include <llvm/IR/Type.h>
+
+#include <string>
+
+#include "type.hpp"
+
+namespace util {
+
+/// @brief Check if a basic block has a terminator instruction.
+/// @return `true` if terminator instruction is found, `false` otherwise.
+bool HasTerminator(llvm::BasicBlock* bb);
+
+/// @brief A collection of wrappers of LLVM types and functions.
+class LLVMIRBuilderHelper {
+ public:
+  /// @brief Every LLVM basic block can only have one terminator instruction.
+  /// This function can check if there are terminator instructions before the
+  /// current insert point. If no, then it will create an unconditional branch
+  /// to the next basic block. If yes, then it will not create branch
+  /// instruction.
+  void CreateBrIfNoBrBefore(llvm::BasicBlock* next_bb);
+
+  /// @brief Create a branch instruction to the next basic block.
+  void CurrBBFallThroughNextBB(llvm::BasicBlock* curr_bb,
+                               llvm::BasicBlock* next_bb);
+
+  /// @brief Find the basic block with the same name as `id` within the current
+  /// function.
+  /// @param id The name of the target basic block.
+  /// @return A pointer to basic block if found. `nullptr` if not found.
+  llvm::BasicBlock* FindBBWithNameOf(const std::string& id);
+
+  /// @brief Get the current function.
+  /// @return A pointer to the current function.
+  llvm::Function* CurrFunc();
+
+  /// @brief Get the corresponding LLVM type from our type.
+  /// @note For Function Pointers, even though it is a pointer type, we return
+  /// `FunctionType` instead of `PointerType` because `FunctionType` is needed
+  /// for creating LLVM IR function call.
+  /// @throw `std::runtime_error` if the `type` is not unknown.
+  llvm::Type* GetLLVMType(const Type& type);
+
+  LLVMIRBuilderHelper(llvm::IRBuilder<>& builder) : builder_{builder} {}
+
+ private:
+  /// @brief Stores a reference from the original builder.
+  llvm::IRBuilder<>&
+      builder_;  // NOLINT(cppcoreguidelines-avoid-const-or-ref-data-members)
+};
+
+}  // namespace util
+
+#endif  // LLVM_UTIL_HPP_

include/llvm_ir_generator.hpp

@@ -0,0 +1,87 @@
+#ifndef LLVM_IR_GENERATOR_HPP_
+#define LLVM_IR_GENERATOR_HPP_
+
+#include <llvm/IR/IRBuilder.h>
+#include <llvm/IR/LLVMContext.h>
+#include <llvm/IR/Module.h>
+#include <llvm/IR/Type.h>
+#include <llvm/Support/raw_os_ostream.h>
+
+#include <ostream>
+#include <string>
+
+#include "ast.hpp"
+#include "llvm/util.hpp"
+#include "visitor.hpp"
+
+class LLVMIRGenerator : public NonModifyingVisitor {
+ public:
+  void Visit(const DeclStmtNode&) override;
+  void Visit(const LoopInitNode&) override;
+  void Visit(const VarDeclNode&) override;
+  void Visit(const ArrDeclNode&) override;
+  void Visit(const RecordDeclNode&) override;
+  void Visit(const FieldNode&) override;
+  void Visit(const RecordVarDeclNode&) override;
+  void Visit(const ParamNode&) override;
+  void Visit(const FuncDefNode&) override;
+  void Visit(const CompoundStmtNode&) override;
+  void Visit(const TransUnitNode&) override;
+  void Visit(const ExternDeclNode&) override;
+  void Visit(const IfStmtNode&) override;
+  void Visit(const WhileStmtNode&) override;
+  void Visit(const ForStmtNode&) override;
+  void Visit(const ReturnStmtNode&) override;
+  void Visit(const GotoStmtNode&) override;
+  void Visit(const BreakStmtNode&) override;
+  void Visit(const ContinueStmtNode&) override;
+  void Visit(const SwitchStmtNode&) override;
+  void Visit(const IdLabeledStmtNode&) override;
+  void Visit(const CaseStmtNode&) override;
+  void Visit(const DefaultStmtNode&) override;
+  void Visit(const ExprStmtNode&) override;
+  void Visit(const InitExprNode&) override;
+  void Visit(const ArrDesNode&) override;
+  void Visit(const IdDesNode&) override;
+  void Visit(const NullExprNode&) override;
+  void Visit(const IdExprNode&) override;
+  void Visit(const IntConstExprNode&) override;
+  void Visit(const ArgExprNode&) override;
+  void Visit(const ArrSubExprNode&) override;
+  void Visit(const CondExprNode&) override;
+  void Visit(const FuncCallExprNode&) override;
+  void Visit(const RecordMemExprNode&) override;
+  void Visit(const PostfixArithExprNode&) override;
+  void Visit(const UnaryExprNode&) override;
+  void Visit(const BinaryExprNode&) override;
+  void Visit(const SimpleAssignmentExprNode&) override;
+
+  LLVMIRGenerator(std::ostream& output, const std::string& filename)
+      : output_{output},
+        context_{},
+        builder_{llvm::IRBuilder<>(context_)},
+        module_{llvm::Module(filename, context_)},
+        builder_helper_{util::LLVMIRBuilderHelper(builder_)} {}
+
+  /// @brief Print LLVM IR to output.
+  void PrintIR() {
+    module_.print(output_, nullptr);
+  }
+
+ private:
+  /// @brief A LLVM ostream wrapper for writing to output.
+  llvm::raw_os_ostream output_;
+  /// @brief A LLVM object that includes core LLVM infrastructure.
+  llvm::LLVMContext context_;
+  /// @brief Provides LLVM Builder API for constructing IR. By default, Constant
+  /// folding is enabled and we have more flexibility for inserting
+  /// instructions.
+  llvm::IRBuilder<> builder_;
+  /// @brief Stores global variables, function lists, and the constructed IR.
+  llvm::Module module_;
+  /// @brief Wrapping IR builder to provide handy LLVM types and functions for
+  /// IR generation.
+  util::LLVMIRBuilderHelper builder_helper_;
+};
+
+#endif  // LLVM_IR_GENERATOR_HPP_

include/type.hpp

@@ -188,12 +188,20 @@ class RecordType : public Type {
   /// @return The type id.
   virtual std::string id()  // NOLINT(readability-identifier-naming)
       const noexcept = 0;
+  /// @return The fields of a record type.
+  virtual const std::vector<std::unique_ptr<Field>>&
+  fields()  // NOLINT(readability-identifier-naming)
+      const noexcept = 0;
   /// @brief Checks if `id` is a member of the record type.
   virtual bool IsMember(const std::string& id) const noexcept = 0;
   /// @return The type of a member in struct or union. The unknown type if the
   /// `id` is not a member of the record type.
   virtual std::unique_ptr<Type> MemberType(
       const std::string& id) const noexcept = 0;
+  /// @note Every member in union shares the same index 0.
+  /// @return The index of a member in struct or union.
+  /// @throw `std::runtime_error` if the `id` is not a member of the record.
+  virtual std::size_t MemberIndex(const std::string& id) const = 0;
   /// @note Every member in union shares the same offset 0.
   /// @return The type offset in the record based on `id`.
   /// @throw `std::runtime_error` if the `id` is not a member of the record.
@@ -214,10 +222,14 @@ class StructType : public RecordType {
   StructType(std::string id, std::vector<std::unique_ptr<Field>> fields)
       : id_{std::move(id)}, fields_{std::move(fields)} {}
 
+  const std::vector<std::unique_ptr<Field>>& fields() const noexcept override {
+    return fields_;
+  }
   std::string id() const noexcept override;
   bool IsMember(const std::string& id) const noexcept override;
   std::unique_ptr<Type> MemberType(
       const std::string& id) const noexcept override;
+  std::size_t MemberIndex(const std::string& id) const override;
   std::size_t OffsetOf(const std::string& id) const override;
   std::size_t OffsetOf(std::size_t index) const override;
   std::size_t SlotCount() const noexcept override;
@@ -243,10 +255,14 @@ class UnionType : public RecordType {
   UnionType(std::string id, std::vector<std::unique_ptr<Field>> fields)
       : id_{std::move(id)}, fields_{std::move(fields)} {}
 
+  const std::vector<std::unique_ptr<Field>>& fields() const noexcept override {
+    return fields_;
+  }
   std::string id() const noexcept override;
   bool IsMember(const std::string& id) const noexcept override;
   std::unique_ptr<Type> MemberType(
       const std::string& id) const noexcept override;
+  std::size_t MemberIndex(const std::string& id) const override;
   std::size_t OffsetOf(const std::string& id) const override;
   std::size_t OffsetOf(std::size_t index) const override;
   std::size_t SlotCount() const noexcept override;