refactor: move all double data type to float (#98)

Move all double data type to float.

This is not really necessary, because soon it should allow both float and double, but we are doing it now in order to identify problems with incompatibility and we need to make the code more flexible.

Author: xmnlab

src/codegen/arx-llvm.cpp

@@ -18,14 +18,14 @@ std::map<std::string, llvm::AllocaInst*> ArxLLVM::named_values;
 std::map<std::string, std::unique_ptr<PrototypeAST>> ArxLLVM::function_protos;
 
 /* Data types */
-llvm::Type* ArxLLVM::DOUBLE_TYPE;
 llvm::Type* ArxLLVM::FLOAT_TYPE;
+llvm::Type* ArxLLVM::DOUBLE_TYPE;
 llvm::Type* ArxLLVM::INT8_TYPE;
 llvm::Type* ArxLLVM::INT32_TYPE;
 
 /* Debug Information Data types */
-llvm::DIType* ArxLLVM::DI_DOUBLE_TYPE;
 llvm::DIType* ArxLLVM::DI_FLOAT_TYPE;
+llvm::DIType* ArxLLVM::DI_DOUBLE_TYPE;
 llvm::DIType* ArxLLVM::DI_INT8_TYPE;
 llvm::DIType* ArxLLVM::DI_INT32_TYPE;
 llvm::DIType* ArxLLVM::DI_VOID_TYPE;
@@ -52,3 +52,22 @@ auto ArxLLVM::get_data_type(std::string type_name) -> llvm::Type* {
   llvm::errs() << "[EE] type_name not valid.\n";
   return nullptr;
 }
+
+auto ArxLLVM::get_di_data_type(std::string di_type_name) -> llvm::DIType* {
+  if (di_type_name == "float") {
+    return ArxLLVM::DI_FLOAT_TYPE;
+  } else if (di_type_name == "double") {
+    return ArxLLVM::DI_DOUBLE_TYPE;
+  } else if (di_type_name == "int8") {
+    return ArxLLVM::DI_INT8_TYPE;
+  } else if (di_type_name == "int32") {
+    return ArxLLVM::DI_INT32_TYPE;
+  } else if (di_type_name == "char") {
+    return ArxLLVM::DI_INT8_TYPE;
+  } else if (di_type_name == "void") {
+    return ArxLLVM::DI_VOID_TYPE;
+  }
+
+  llvm::errs() << "[EE] di_type_name not valid.\n";
+  return nullptr;
+}

src/codegen/arx-llvm.h

@@ -34,6 +34,7 @@ class ArxLLVM {
   static llvm::DIType* DI_VOID_TYPE;
 
   static auto get_data_type(std::string type_name) -> llvm::Type*;
+  static auto get_di_data_type(std::string type_name) -> llvm::DIType*;
 };
 
 extern bool IS_BUILD_LIB;

src/codegen/ast-to-llvm-ir.cpp

@@ -45,13 +45,12 @@ extern std::string ARX_VERSION;
 auto ASTToLLVMIRVisitor::CreateFunctionType(unsigned NumArgs)
   -> llvm::DISubroutineType* {
   llvm::SmallVector<llvm::Metadata*, 8> EltTys;
-  llvm::DIType* DblTy = this->getDoubleTy();
 
   // Add the result type.
-  EltTys.emplace_back(DblTy);
+  EltTys.emplace_back(ArxLLVM::DI_FLOAT_TYPE);
 
   for (unsigned i = 0, e = NumArgs; i != e; ++i) {
-    EltTys.emplace_back(DblTy);
+    EltTys.emplace_back(ArxLLVM::DI_FLOAT_TYPE);
   }
 
   return ArxLLVM::di_builder->createSubroutineType(
@@ -60,30 +59,20 @@ auto ASTToLLVMIRVisitor::CreateFunctionType(unsigned NumArgs)
 
 // DebugInfo
 
-auto ASTToLLVMIRVisitor::getDoubleTy() -> llvm::DIType* {
-  if (this->DblTy) {
-    return this->DblTy;
-  }
-
-  DblTy = ArxLLVM::di_builder->createBasicType(
-    "double", 64, llvm::dwarf::DW_ATE_float);
-  return DblTy;
-}
-
 auto ASTToLLVMIRVisitor::emitLocation(ExprAST& ast) -> void {
   if (!std::addressof(ast)) {
     return ArxLLVM::ir_builder->SetCurrentDebugLocation(llvm::DebugLoc());
   }
 
-  llvm::DIScope* Scope;
+  llvm::DIScope* di_scope;
   if (this->llvm_di_lexical_blocks.empty()) {
-    Scope = llvm_di_compile_unit;
+    di_scope = llvm_di_compile_unit;
   } else {
-    Scope = this->llvm_di_lexical_blocks.back();
+    di_scope = this->llvm_di_lexical_blocks.back();
   }
 
   ArxLLVM::ir_builder->SetCurrentDebugLocation(llvm::DILocation::get(
-    Scope->getContext(), ast.get_line(), ast.getCol(), Scope));
+    di_scope->getContext(), ast.get_line(), ast.getCol(), di_scope));
 }
 
 /**
@@ -191,26 +180,26 @@ auto ASTToLLVMIRVisitor::visit(FunctionAST& expr) -> void {
 
   /* debugging-code:start*/
   // Create a subprogram DIE for this function.
-  llvm::DIFile* Unit = ArxLLVM::di_builder->createFile(
+  llvm::DIFile* di_unit = ArxLLVM::di_builder->createFile(
     this->llvm_di_compile_unit->getFilename(),
     this->llvm_di_compile_unit->getDirectory());
-  llvm::DIScope* FContext = Unit;
-  unsigned LineNo = proto.get_line();
-  unsigned ScopeLine = LineNo;
-  llvm::DISubprogram* SP = ArxLLVM::di_builder->createFunction(
-    FContext,
+  llvm::DIScope* file_context = di_unit;
+  unsigned line_no = proto.get_line();
+  unsigned ScopeLine = line_no;
+  llvm::DISubprogram* di_subprogram = ArxLLVM::di_builder->createFunction(
+    file_context,
     proto.get_name(),
     llvm::StringRef(),
-    Unit,
-    LineNo,
+    di_unit,
+    line_no,
     CreateFunctionType(the_function->arg_size()),
     ScopeLine,
     llvm::DINode::FlagPrototyped,
     llvm::DISubprogram::SPFlagDefinition);
-  the_function->setSubprogram(SP);
+  the_function->setSubprogram(di_subprogram);
 
   // Push the current scope.
-  this->llvm_di_lexical_blocks.emplace_back(SP);
+  this->llvm_di_lexical_blocks.emplace_back(di_subprogram);
 
   // Unset the location for the prologue emission (leading instructions with no
   // location in a function are considered part of the prologue and the
@@ -224,28 +213,30 @@ auto ASTToLLVMIRVisitor::visit(FunctionAST& expr) -> void {
   // std::cout << "Record the function arguments in the named_values map.";
   ArxLLVM::named_values.clear();
 
-  unsigned ArgIdx = 0;
+  unsigned arg_idx = 0;
   for (auto& llvm_arg : the_function->args()) {
     // Create an alloca for this variable.
     llvm::AllocaInst* alloca =
       CreateEntryBlockAlloca(the_function, llvm_arg.getName());
 
     /* debugging-code: start */
     // Create a debug descriptor for the variable.
-    llvm::DILocalVariable* D = ArxLLVM::di_builder->createParameterVariable(
-      SP,
-      llvm_arg.getName(),
-      ++ArgIdx,
-      Unit,
-      LineNo,
-      this->getDoubleTy(),
-      true);
+    llvm::DILocalVariable* di_local_variable =
+      ArxLLVM::di_builder->createParameterVariable(
+        di_subprogram,
+        llvm_arg.getName(),
+        ++arg_idx,
+        di_unit,
+        line_no,
+        ArxLLVM::DI_FLOAT_TYPE,
+        true);
 
     ArxLLVM::di_builder->insertDeclare(
       alloca,
-      D,
+      di_local_variable,
       ArxLLVM::di_builder->createExpression(),
-      llvm::DILocation::get(SP->getContext(), LineNo, 0, SP),
+      llvm::DILocation::get(
+        di_subprogram->getContext(), line_no, 0, di_subprogram),
       ArxLLVM::ir_builder->GetInsertBlock());
 
     /* debugging-code-end */
@@ -297,6 +288,16 @@ auto ASTToLLVMIRVisitor::initialize() -> void {
   ArxLLVM::module->setDataLayout(ArxLLVM::jit->get_data_layout());
   /** Create a new builder for the module. */
   ArxLLVM::di_builder = std::make_unique<llvm::DIBuilder>(*ArxLLVM::module);
+
+  /* di data types */
+  ArxLLVM::DI_FLOAT_TYPE = ArxLLVM::di_builder->createBasicType(
+    "float", 32, llvm::dwarf::DW_ATE_float);
+  ArxLLVM::DI_DOUBLE_TYPE = ArxLLVM::di_builder->createBasicType(
+    "double", 64, llvm::dwarf::DW_ATE_float);
+  ArxLLVM::DI_INT8_TYPE = ArxLLVM::di_builder->createBasicType(
+    "int8", 8, llvm::dwarf::DW_ATE_signed);
+  ArxLLVM::DI_INT32_TYPE = ArxLLVM::di_builder->createBasicType(
+    "int32", 32, llvm::dwarf::DW_ATE_signed);
 }
 
 /**

src/codegen/ast-to-llvm-ir.h

@@ -1,5 +1,7 @@
 #pragma once
 
+#include <vector>  // for vector
+
 #include <llvm/ADT/APFloat.h>
 #include <llvm/ADT/Optional.h>
 #include <llvm/ADT/STLExtras.h>
@@ -20,6 +22,7 @@
 #include <llvm/IR/Type.h>
 #include <llvm/IR/Verifier.h>
 #include <llvm/MC/TargetRegistry.h>
+#include <llvm/Support/Error.h>  // for ExitOnError
 #include <llvm/Support/FileSystem.h>
 #include <llvm/Support/Host.h>
 #include <llvm/Support/raw_ostream.h>
@@ -38,7 +41,6 @@ class ASTToLLVMIRVisitor : public ASTToObjectVisitor {
  public:
   // DebugInfo
   llvm::DICompileUnit* llvm_di_compile_unit;
-  llvm::DIType* DblTy;
   std::vector<llvm::DIScope*> llvm_di_lexical_blocks;
 
   llvm::ExitOnError exit_on_err;
@@ -61,5 +63,4 @@ class ASTToLLVMIRVisitor : public ASTToObjectVisitor {
 
   // DebugInfo
   void emitLocation(ExprAST& AST);
-  llvm::DIType* getDoubleTy();
 };

src/codegen/ast-to-object.cpp

@@ -1,12 +1,9 @@
 #include <cassert>  // for assert
 #include <cstdio>   // for fprintf, stderr, fputc
 #include <cstdlib>  // for exit
-#include <fstream>  // for operator<<
 #include <iostream>
-#include <map>      // for map, operator==, _Rb_tree_ite...
-#include <memory>   // for unique_ptr, allocator, make_u...
-#include <numeric>  // for accumulate
-#include <sstream>
+#include <map>           // for map, operator==, _Rb_tree_ite...
+#include <memory>        // for unique_ptr, allocator, make_u...
 #include <string>        // for string, operator<=>, operator+
 #include <system_error>  // for error_code
 #include <utility>       // for pair, move
@@ -101,7 +98,7 @@ auto ASTToObjectVisitor::getFunction(std::string name) -> void {
 auto ASTToObjectVisitor::CreateEntryBlockAlloca(
   llvm::Function* fn, llvm::StringRef var_name) -> llvm::AllocaInst* {
   llvm::IRBuilder<> TmpB(&fn->getEntryBlock(), fn->getEntryBlock().begin());
-  return TmpB.CreateAlloca(ArxLLVM::DOUBLE_TYPE, nullptr, var_name);
+  return TmpB.CreateAlloca(ArxLLVM::FLOAT_TYPE, nullptr, var_name);
 }
 
 /**
@@ -136,7 +133,7 @@ auto ASTToObjectVisitor::visit(VariableExprAST& expr) -> void {
   }
 
   this->result_val = ArxLLVM::ir_builder->CreateLoad(
-    ArxLLVM::DOUBLE_TYPE, expr_var, expr.name.c_str());
+    ArxLLVM::FLOAT_TYPE, expr_var, expr.name.c_str());
 }
 
 /**
@@ -227,9 +224,9 @@ auto ASTToObjectVisitor::visit(BinaryExprAST& expr) -> void {
     case '<':
       llvm_val_lhs = ArxLLVM::ir_builder->CreateFCmpULT(
         llvm_val_lhs, llvm_val_rhs, "cmptmp");
-      // Convert bool 0/1 to double 0.0 or 1.0 //
+      // Convert bool 0/1 to float 0.0 or 1.0 //
       this->result_val = ArxLLVM::ir_builder->CreateUIToFP(
-        llvm_val_lhs, ArxLLVM::DOUBLE_TYPE, "booltmp");
+        llvm_val_lhs, ArxLLVM::FLOAT_TYPE, "booltmp");
       return;
   }
 
@@ -341,7 +338,7 @@ auto ASTToObjectVisitor::visit(IfExprAST& expr) -> void {
   fn->getBasicBlockList().push_back(MergeBB);
   ArxLLVM::ir_builder->SetInsertPoint(MergeBB);
   llvm::PHINode* PN =
-    ArxLLVM::ir_builder->CreatePHI(ArxLLVM::DOUBLE_TYPE, 2, "iftmp");
+    ArxLLVM::ir_builder->CreatePHI(ArxLLVM::FLOAT_TYPE, 2, "iftmp");
 
   PN->addIncoming(ThenV, ThenBB);
   PN->addIncoming(ElseV, ElseBB);
@@ -426,7 +423,7 @@ auto ASTToObjectVisitor::visit(ForExprAST& expr) -> void {
   // Reload, increment, and restore the alloca.  This handles the case
   // where the body of the loop mutates the variable.
   llvm::Value* CurVar = ArxLLVM::ir_builder->CreateLoad(
-    ArxLLVM::DOUBLE_TYPE, alloca, expr.var_name.c_str());
+    ArxLLVM::FLOAT_TYPE, alloca, expr.var_name.c_str());
   llvm::Value* NextVar =
     ArxLLVM::ir_builder->CreateFAdd(CurVar, StepVal, "nextvar");
   ArxLLVM::ir_builder->CreateStore(NextVar, alloca);
@@ -455,7 +452,7 @@ auto ASTToObjectVisitor::visit(ForExprAST& expr) -> void {
   }
 
   // for expr always returns 0.0.
-  this->result_val = llvm::Constant::getNullValue(ArxLLVM::DOUBLE_TYPE);
+  this->result_val = llvm::Constant::getNullValue(ArxLLVM::FLOAT_TYPE);
 }
 
 /**
@@ -523,8 +520,8 @@ auto ASTToObjectVisitor::visit(VarExprAST& expr) -> void {
  *
  */
 auto ASTToObjectVisitor::visit(PrototypeAST& expr) -> void {
-  std::vector<llvm::Type*> args_type(expr.args.size(), ArxLLVM::DOUBLE_TYPE);
-  llvm::Type* return_type = ArxLLVM::get_data_type("double");
+  std::vector<llvm::Type*> args_type(expr.args.size(), ArxLLVM::FLOAT_TYPE);
+  llvm::Type* return_type = ArxLLVM::get_data_type("float");
 
   llvm::FunctionType* fn_type =
     llvm::FunctionType::get(return_type, args_type, false /* isVarArg */);
@@ -616,7 +613,7 @@ auto ASTToObjectVisitor::initialize() -> void {
   ArxLLVM::ir_builder = std::make_unique<llvm::IRBuilder<>>(*ArxLLVM::context);
 
   /* Data Types */
-  ArxLLVM::DOUBLE_TYPE = llvm::Type::getFloatTy(*ArxLLVM::context);
+  ArxLLVM::FLOAT_TYPE = llvm::Type::getFloatTy(*ArxLLVM::context);
   ArxLLVM::DOUBLE_TYPE = llvm::Type::getDoubleTy(*ArxLLVM::context);
   ArxLLVM::INT8_TYPE = llvm::Type::getInt8Ty(*ArxLLVM::context);
   ArxLLVM::INT32_TYPE = llvm::Type::getInt32Ty(*ArxLLVM::context);
@@ -644,19 +641,19 @@ auto ASTToObjectVisitor::main_loop(TreeAST& ast) -> void {
 #endif
 
 /**
- * @brief putchar that takes a double and returns 0.
+ * @brief putchar that takes a float and returns 0.
  *
  */
-extern "C" DLLEXPORT auto putchard(double X) -> double {
+extern "C" DLLEXPORT auto putchard(float X) -> float {
   fputc(static_cast<char>(X), stderr);
   return 0;
 }
 
 /**
- * @brief printf that takes a double prints it as "%f\n", returning 0.
+ * @brief printf that takes a float prints it as "%f\n", returning 0.
  *
  */
-extern "C" DLLEXPORT auto printd(double X) -> double {
+extern "C" DLLEXPORT auto printd(float X) -> float {
   fprintf(stderr, "%f\n", X);
   return 0;
 }

src/lexer.cpp

@@ -9,7 +9,7 @@ SourceLocation Lexer::cur_loc;
 // Filled in if tok_identifier
 std::string Lexer::identifier_str = "<NOT DEFINED>";
 // Filled in if tok_float_literal
-double Lexer::num_float;
+float Lexer::num_float;
 SourceLocation Lexer::lex_loc;
 int Lexer::cur_tok = tok_not_initialized;
 

src/lexer.h

@@ -47,7 +47,7 @@ class Lexer {
  public:
   static SourceLocation cur_loc;
   static std::string identifier_str;  // Filled in if tok_identifier
-  static double num_float;            // Filled in if tok_float_literal
+  static float num_float;             // Filled in if tok_float_literal
   static int cur_tok;
   static SourceLocation lex_loc;
 

src/parser.h

@@ -98,9 +98,9 @@ class ExprAST {
  */
 class FloatExprAST : public ExprAST {
  public:
-  double val;
+  float val;
 
-  FloatExprAST(double _val) : val(_val) {
+  FloatExprAST(float _val) : val(_val) {
     this->kind = ExprKind::FloatDTKind;
   }
 

tests/integration/average.cpp

@@ -1,10 +1,10 @@
 #include <iostream>
 
 extern "C" {
-double average(double, double);
+float average(float, float);
 }
 
 int main() {
-  double avg_3_4 = average(3.0, 4.0);
+  float avg_3_4 = average(3.0, 4.0);
   std::cout << "average of 3.0 and 4.0: " << avg_3_4 << std::endl;
 }

tests/integration/constant.cpp

@@ -1,11 +1,11 @@
 #include <iostream>
 
 extern "C" {
-double get_constant(double);
+float get_constant(float);
 }
 
 int main() {
-  double value = get_constant(3.0);
+  float value = get_constant(3.0);
   printf("get_constant(3.0): %f\n", value);
 
   return 0;