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
 

include/llvm/util.hpp

@@ -0,0 +1,63 @@
+#ifndef LLVM_UTIL_HPP_
+#define LLVM_UTIL_HPP_
+
+#include <llvm/IR/BasicBlock.h>
+#include <llvm/IR/DerivedTypes.h>
+#include <llvm/IR/Function.h>
+#include <llvm/IR/IRBuilder.h>
+#include <llvm/IR/Type.h>
+
+#include <memory>
+#include <string>
+
+#include "type.hpp"
+
+namespace util {
+
+/// @brief A collection of wrappers of LLVM types and functions.
+class LLVMIRUtil {
+ public:
+  /// @brief LLVM Integer type
+  llvm::IntegerType* IntType();
+  /// @brief LLVM Pointer type
+  llvm::PointerType* IntPtrType();
+
+  /// @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);
+
+  LLVMIRUtil(std::unique_ptr<llvm::IRBuilder<>>& builder) : builder_{builder} {}
+
+ private:
+  /// @brief Stores a reference from the original builder.
+  std::unique_ptr<llvm::IRBuilder<>>&  // XXX: Ignore check until refactor.
+      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 <memory>
+#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, std::string& filename)
+      : output_{output},
+        context_{std::make_unique<llvm::LLVMContext>()},
+        builder_{std::make_unique<llvm::IRBuilder<>>(*context_)},
+        module_{std::make_unique<llvm::Module>(filename, *context_)},
+        llvm_util_{util::LLVMIRUtil(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.
+  std::unique_ptr<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.
+  std::unique_ptr<llvm::IRBuilder<>> builder_;
+  /// @brief Stores global variables, function lists, and the constructed IR.
+  std::unique_ptr<llvm::Module> module_;
+  /// @brief Handy LLVM types and functions for code generation.
+  util::LLVMIRUtil llvm_util_;
+};
+
+#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;

main.cpp

@@ -7,9 +7,12 @@
 #include <fstream>
 #include <iostream>
 #include <memory>
+#include <string>
+#include <utility>
 
 #include "ast.hpp"
 #include "ast_dumper.hpp"
+#include "llvm_ir_generator.hpp"
 #include "qbe_ir_generator.hpp"
 #include "scope.hpp"
 #include "type_checker.hpp"
@@ -22,6 +25,12 @@ extern FILE*
 extern void yylex_destroy();  // NOLINT(readability-identifier-naming): extern
                               // from flex generated code.
 
+int QbeBuilder(std::unique_ptr<AstNode> trans_unit, std::string& input_basename,
+               std::string& output_name);
+
+int LLVMBuilder(std::unique_ptr<AstNode> trans_unit,
+                std::string& input_basename, std::string& output_name);
+
 int main(  // NOLINT(bugprone-exception-escape): Using a big try-catch block to
            // catch all exceptions isn't reasonable.
     int argc, char** argv)
@@ -36,8 +45,7 @@ int main(  // NOLINT(bugprone-exception-escape): Using a big try-catch block to
   cmd_options.add_options()
       ("o, output", "Write output to <file>", cxxopts::value<std::string>()->default_value("a.out"), "<file>")
       ("d, dump", "Dump the abstract syntax tree", cxxopts::value<bool>()->default_value("false"))
-      // TODO: support LLVM IR
-      ("t, target", "Specify target IR", cxxopts::value<std::string>()->default_value("qbe"), "[qbe]")
+      ("t, target", "Specify target IR", cxxopts::value<std::string>()->default_value("qbe"), "[qbe|llvm]")
       ("h, help", "Display available options")
       ;
   // clang-format on
@@ -68,7 +76,7 @@ int main(  // NOLINT(bugprone-exception-escape): Using a big try-catch block to
     std::exit(0);
   }
 
-  /// @brief The root node of the program.
+  /// @brief The root node of the trans_unit.
   auto trans_unit = std::unique_ptr<AstNode>{};
   yy::parser parser{trans_unit};
   int ret = parser.parse();
@@ -93,31 +101,39 @@ int main(  // NOLINT(bugprone-exception-escape): Using a big try-catch block to
     trans_unit->Accept(ast_dumper);
   }
 
-  // generate intermediate representation
   auto input_basename = input_path.stem().string();
+  auto output = opts["output"].as<std::string>();
+  // generate intermediate representation based on target option
+  if (opts["target"].as<std::string>() == "qbe") {
+    return QbeBuilder(std::move(trans_unit), input_basename, output);
+  } else if (opts["target"].as<std::string>() == "llvm") {
+    return LLVMBuilder(std::move(trans_unit), input_basename, output);
+  } else {
+    std::cerr << "unknown target" << '\n';
+    std::exit(0);
+  }
+
+  return 0;
+}
+
+int QbeBuilder(std::unique_ptr<AstNode> trans_unit, std::string& input_basename,
+               std::string& output_name) {
   auto output_ir = std::ofstream{fmt::format("{}.ssa", input_basename)};
   QbeIrGenerator code_generator{output_ir};
   trans_unit->Accept(code_generator);
 
   output_ir.close();
 
   // generate assembly
-  if (opts["target"].as<std::string>() == "qbe") {
-    std::string qbe_command =
-        fmt::format("qbe -o {0}.s {0}.ssa", input_basename);
-    auto qbe_ret = std::system(qbe_command.c_str());
-    // 0 on success, 1 otherwise
-    if (qbe_ret) {
-      return qbe_ret;
-    }
-  } else {
-    std::cerr << "unknown target" << '\n';
-    std::exit(0);
+  std::string qbe_command = fmt::format("qbe -o {0}.s {0}.ssa", input_basename);
+  auto qbe_ret = std::system(qbe_command.c_str());
+  // 0 on success, 1 otherwise
+  if (qbe_ret) {
+    return qbe_ret;
   }
-
   // generate executable
-  auto output = opts["output"].as<std::string>();
-  std::string cc_command = fmt::format("cc -o {} {}.s", output, input_basename);
+  std::string cc_command =
+      fmt::format("cc -o {} {}.s", output_name, input_basename);
   auto cc_ret = std::system(cc_command.c_str());
   // 0 on success, 1 otherwise
   if (cc_ret) {
@@ -126,3 +142,16 @@ int main(  // NOLINT(bugprone-exception-escape): Using a big try-catch block to
 
   return 0;
 }
+
+int LLVMBuilder(std::unique_ptr<AstNode> trans_unit,
+                std::string& input_basename, std::string& output_name) {
+  auto output_ir = std::ofstream{fmt::format("{}.ll", input_basename)};
+  LLVMIRGenerator code_generator{output_ir, input_basename};
+  trans_unit->Accept(code_generator);
+  // TODO: Write to stdout based on cxxopts.
+  // Write LLVM IR to output file "*.ll".
+  code_generator.PrintIR();
+
+  output_ir.close();
+  return 0;
+}