diff --git a/src/backend/codegen/.gitignore b/src/backend/codegen/.gitignore index 5f3536be555aa5e471b96ba3335a01675e704714..59bfc01864800f24098dbc6335be3b5b668deca1 100644 --- a/src/backend/codegen/.gitignore +++ b/src/backend/codegen/.gitignore @@ -43,3 +43,4 @@ CTestTestfile.cmake cmake_install.cmake install_manifest.txt Makefile +Testing diff --git a/src/backend/codegen/CMakeLists.txt b/src/backend/codegen/CMakeLists.txt index 4f058f2ad2416acc9b0adeeb29ce8d35089a932c..1deed7f9e92da0c8b101573e49f73dea48583688 100644 --- a/src/backend/codegen/CMakeLists.txt +++ b/src/backend/codegen/CMakeLists.txt @@ -164,7 +164,7 @@ set(GPCODEGEN_SRC codegen_interface.cc codegen_manager.cc codegen_wrapper.cc - ExecVariableList_codegen.cc + exec_variable_list_codegen.cc ) # Integrate with GPDB build system. diff --git a/src/backend/codegen/codegen_manager.cc b/src/backend/codegen/codegen_manager.cc index 5d42799c07db04289c3067549cbb507b85521448..35a164ab0308640ee4be9de919403444004994ac 100644 --- a/src/backend/codegen/codegen_manager.cc +++ b/src/backend/codegen/codegen_manager.cc @@ -10,6 +10,10 @@ // //--------------------------------------------------------------------------- +extern "C" { +#include +} + #include #include @@ -36,10 +40,6 @@ #include "llvm/IR/Verifier.h" #include "llvm/Support/Casting.h" -extern "C" { -#include -} - using gpcodegen::CodegenManager; CodegenManager::CodegenManager(const std::string& module_name) { @@ -66,7 +66,6 @@ unsigned int CodegenManager::GenerateCode() { } unsigned int CodegenManager::PrepareGeneratedFunctions() { - unsigned int success_count = 0; // If no generator registered, just return with success count as 0 diff --git a/src/backend/codegen/codegen_wrapper.cc b/src/backend/codegen/codegen_wrapper.cc index f4bb5bda523972449a5267e82b403940bd3c10b1..812cf03bb9eec6f49db9168ba0695f54dba776cd 100644 --- a/src/backend/codegen/codegen_wrapper.cc +++ b/src/backend/codegen/codegen_wrapper.cc @@ -12,7 +12,7 @@ #include "codegen/codegen_wrapper.h" #include "codegen/codegen_manager.h" -#include "codegen/ExecVariableList_codegen.h" +#include "codegen/exec_variable_list_codegen.h" #include "codegen/utils/codegen_utils.h" @@ -111,7 +111,7 @@ void* ExecVariableListCodegenEnroll( ExecVariableListFn regular_func_ptr, ExecVariableListFn* ptr_to_chosen_func_ptr, ProjectionInfo* proj_info, - TupleTableSlot* slot) { + TupleTableSlot* slot) { ExecVariableListCodegen* generator = CodegenEnroll( regular_func_ptr, ptr_to_chosen_func_ptr, proj_info, slot); return generator; diff --git a/src/backend/codegen/ExecVariableList_codegen.cc b/src/backend/codegen/exec_variable_list_codegen.cc similarity index 81% rename from src/backend/codegen/ExecVariableList_codegen.cc rename to src/backend/codegen/exec_variable_list_codegen.cc index c0790d383eb49302f112b259c99782017f573e94..fca71ad853e383ae7519632f5838f7365bf9a019 100644 --- a/src/backend/codegen/ExecVariableList_codegen.cc +++ b/src/backend/codegen/exec_variable_list_codegen.cc @@ -9,11 +9,12 @@ // Contains different code generators // //--------------------------------------------------------------------------- +#include "codegen/exec_variable_list_codegen.h" + #include #include #include -#include "codegen/ExecVariableList_codegen.h" #include "codegen/utils/clang_compiler.h" #include "codegen/utils/utility.h" #include "codegen/utils/instance_method_wrappers.h" @@ -49,7 +50,7 @@ constexpr char ExecVariableListCodegen::kExecVariableListPrefix[]; class ElogWrapper { public: - ElogWrapper(gpcodegen::CodegenUtils* codegen_utils) : + explicit ElogWrapper(gpcodegen::CodegenUtils* codegen_utils) : codegen_utils_(codegen_utils) { SetupElog(); } @@ -62,15 +63,14 @@ class ElogWrapper { llvm::Value* llvm_elevel, llvm::Value* llvm_fmt, V ... args ) { - assert(NULL != llvm_elevel); assert(NULL != llvm_fmt); codegen_utils_->ir_builder()->CreateCall( llvm_elog_start_, { - codegen_utils_->GetConstant(""), // Filename - codegen_utils_->GetConstant(0), // line number - codegen_utils_->GetConstant("") // function name + codegen_utils_->GetConstant(""), // Filename + codegen_utils_->GetConstant(0), // line number + codegen_utils_->GetConstant("") // function name }); codegen_utils_->ir_builder()->CreateCall( llvm_elog_finish_, { @@ -88,13 +88,14 @@ class ElogWrapper { codegen_utils_->GetConstant(fmt), args...); } + private: llvm::Function* llvm_elog_start_; llvm::Function* llvm_elog_finish_; gpcodegen::CodegenUtils* codegen_utils_; - void SetupElog(){ + void SetupElog() { assert(codegen_utils_ != nullptr); llvm_elog_start_ = codegen_utils_->RegisterExternalFunction(elog_start); assert(llvm_elog_start_ != nullptr); @@ -106,7 +107,6 @@ class ElogWrapper { llvm_elog_start_ = nullptr; llvm_elog_finish_ = nullptr; } - }; ExecVariableListCodegen::ExecVariableListCodegen @@ -115,7 +115,9 @@ ExecVariableListCodegen::ExecVariableListCodegen ExecVariableListFn* ptr_to_regular_func_ptr, ProjectionInfo* proj_info, TupleTableSlot* slot) : - BaseCodegen(kExecVariableListPrefix, regular_func_ptr, ptr_to_regular_func_ptr), + BaseCodegen(kExecVariableListPrefix, + regular_func_ptr, + ptr_to_regular_func_ptr), proj_info_(proj_info), slot_(slot) { } @@ -127,18 +129,23 @@ bool ExecVariableListCodegen::GenerateExecVariableList( assert(NULL != codegen_utils); ElogWrapper elogwrapper(codegen_utils); - static_assert(sizeof(Datum) == sizeof(int64), "sizeof(Datum) doesn't match sizeof(int64)"); + static_assert(sizeof(Datum) == sizeof(int64), + "sizeof(Datum) doesn't match sizeof(int64)"); if ( NULL == proj_info_->pi_varSlotOffsets ) { - elog(DEBUG1, "Cannot codegen ExecVariableList because varSlotOffsets are null"); + elog(DEBUG1, + "Cannot codegen ExecVariableList because varSlotOffsets are null"); return false; } - // Only do codegen if all the elements in the target list are on the same tuple slot - // This is an assumption for scan nodes, but we fall back when joins are involved. - for (int i = list_length(proj_info_->pi_targetlist) - 1; i > 0; i--){ - if (proj_info_->pi_varSlotOffsets[i] != proj_info_->pi_varSlotOffsets[i-1]){ - elog(DEBUG1, "Cannot codegen ExecVariableList because multiple slots to deform."); + // Only do codegen if all the elements in the target list are on the same + // tuple slot This is an assumption for scan nodes, but we fall back when + // joins are involved. + for (int i = list_length(proj_info_->pi_targetlist) - 1; i > 0; i--) { + if (proj_info_->pi_varSlotOffsets[i] != + proj_info_->pi_varSlotOffsets[i-1]) { + elog(DEBUG1, + "Cannot codegen ExecVariableList because multiple slots to deform."); return false; } } @@ -149,42 +156,43 @@ bool ExecVariableListCodegen::GenerateExecVariableList( proj_info_->pi_varNumbers + list_length(proj_info_->pi_targetlist)); // System attribute - if(max_attr <= 0) - { - elog(DEBUG1, "Cannot generate code for ExecVariableList because max_attr is negative (i.e., system attribute)."); + if (max_attr <= 0) { + elog(DEBUG1, "Cannot generate code for ExecVariableList" + "because max_attr is negative (i.e., system attribute)."); return false; - }else if (max_attr > slot_->tts_tupleDescriptor->natts) { - elog(DEBUG1, "Cannot generate code for ExecVariableList because max_attr is greater than natts."); + } else if (max_attr > slot_->tts_tupleDescriptor->natts) { + elog(DEBUG1, "Cannot generate code for ExecVariableList" + "because max_attr is greater than natts."); return false; } // So looks like we're going to generate code - llvm::Function* ExecVariableList_func = CreateFunction( + llvm::Function* exec_variable_list_func = CreateFunction( codegen_utils, GetUniqueFuncName()); auto irb = codegen_utils->ir_builder(); // BasicBlock of function entry. llvm::BasicBlock* entry_block = codegen_utils->CreateBasicBlock( - "entry", ExecVariableList_func); + "entry", exec_variable_list_func); // BasicBlock for checking correct slot llvm::BasicBlock* slot_check_block = codegen_utils->CreateBasicBlock( - "slot_check", ExecVariableList_func); + "slot_check", exec_variable_list_func); // BasicBlock for checking tuple type. llvm::BasicBlock* tuple_type_check_block = codegen_utils->CreateBasicBlock( - "tuple_type_check", ExecVariableList_func); + "tuple_type_check", exec_variable_list_func); // BasicBlock for heap tuple check. llvm::BasicBlock* heap_tuple_check_block = codegen_utils->CreateBasicBlock( - "heap_tuple_check", ExecVariableList_func); + "heap_tuple_check", exec_variable_list_func); // BasicBlock for main. llvm::BasicBlock* main_block = codegen_utils->CreateBasicBlock( - "main", ExecVariableList_func); + "main", exec_variable_list_func); // BasicBlock for final computations. llvm::BasicBlock* final_block = codegen_utils->CreateBasicBlock( - "final", ExecVariableList_func); + "final", exec_variable_list_func); // BasicBlock for fall back. llvm::BasicBlock* fallback_block = codegen_utils->CreateBasicBlock( - "fallback", ExecVariableList_func); + "fallback", exec_variable_list_func); // External functions llvm::Function* llvm_memset = codegen_utils->RegisterExternalFunction(memset); @@ -194,9 +202,9 @@ bool ExecVariableListCodegen::GenerateExecVariableList( llvm::Value* llvm_slot = codegen_utils->GetConstant(slot_); // Function arguments to ExecVariableList - llvm::Value* llvm_projInfo_arg = ArgumentByPosition(ExecVariableList_func, 0); - llvm::Value* llvm_values_arg = ArgumentByPosition(ExecVariableList_func, 1); - llvm::Value* llvm_isnull_arg = ArgumentByPosition(ExecVariableList_func, 2); + llvm::Value* llvm_projInfo_arg = ArgumentByPosition(exec_variable_list_func, 0); + llvm::Value* llvm_values_arg = ArgumentByPosition(exec_variable_list_func, 1); + llvm::Value* llvm_isnull_arg = ArgumentByPosition(exec_variable_list_func, 2); // Entry block // ----------- @@ -228,8 +236,7 @@ bool ExecVariableListCodegen::GenerateExecVariableList( irb->CreateCondBr( irb->CreateICmpEQ(llvm_slot, llvm_slot_arg), tuple_type_check_block /* true */, - fallback_block /* false */ - ); + fallback_block /* false */); // Tuple type check block // ---------------------- @@ -253,7 +260,8 @@ bool ExecVariableListCodegen::GenerateExecVariableList( // slot->PRIVATE_tts_memtuple != NULL llvm::Value* llvm_tuple_has_memtuple = irb->CreateICmpNE( - llvm_slot_PRIVATE_tts_memtuple, codegen_utils->GetConstant((MemTuple) NULL)); + llvm_slot_PRIVATE_tts_memtuple, + codegen_utils->GetConstant((MemTuple) NULL)); // Fall back if tuple is virtual or memtuple is null irb->CreateCondBr( @@ -278,19 +286,18 @@ bool ExecVariableListCodegen::GenerateExecVariableList( // Main block // ---------- - // We generate code for slot_deform_tuple. - // Note that we do not need to check the type of the tuple, since previous check - // guarantees that the we use the enrolled slot, which includes a heap tuple. + // We generate code for slot_deform_tuple. Note that we do not need to check + // the type of the tuple, since previous check guarantees that the we use the + // enrolled slot, which includes a heap tuple. irb->SetInsertPoint(main_block); llvm::Value* llvm_heaptuple_t_data = irb->CreateLoad(codegen_utils->GetPointerToMember( llvm_slot_PRIVATE_tts_heaptuple, - &HeapTupleData::t_data - )); + &HeapTupleData::t_data)); llvm::Value* llvm_heaptuple_t_data_t_infomask = - irb->CreateLoad( codegen_utils->GetPointerToMember( + irb->CreateLoad(codegen_utils->GetPointerToMember( llvm_heaptuple_t_data, &HeapTupleHeaderData::t_infomask)); // Implementation for : {{{ @@ -310,18 +317,17 @@ bool ExecVariableListCodegen::GenerateExecVariableList( irb->CreateSelect( irb->CreateICmpSLT(llvm_attno_t0, llvm_max_attr), llvm_attno_t0, - llvm_max_attr - ); + llvm_max_attr); // }}} // Retrieve slot's PRIVATE variables - llvm::Value* llvm_slot_PRIVATE_tts_isnull /* bool* */= + llvm::Value* llvm_slot_PRIVATE_tts_isnull /* bool* */ = irb->CreateLoad(codegen_utils->GetPointerToMember( llvm_slot, &TupleTableSlot::PRIVATE_tts_isnull)); - llvm::Value* llvm_slot_PRIVATE_tts_values /* Datum* */= + llvm::Value* llvm_slot_PRIVATE_tts_values /* Datum* */ = irb->CreateLoad(codegen_utils->GetPointerToMember( llvm_slot, &TupleTableSlot::PRIVATE_tts_values)); - llvm::Value* llvm_slot_PRIVATE_tts_nvalid_ptr /* int* */= + llvm::Value* llvm_slot_PRIVATE_tts_nvalid_ptr /* int* */ = codegen_utils->GetPointerToMember( llvm_slot, &TupleTableSlot::PRIVATE_tts_nvalid); @@ -357,7 +363,7 @@ bool ExecVariableListCodegen::GenerateExecVariableList( // block of first attribute attribute_block = codegen_utils->CreateBasicBlock( - "attribute_block_"+0, ExecVariableList_func); + "attribute_block_"+0, exec_variable_list_func); irb->CreateBr(attribute_block); @@ -379,7 +385,7 @@ bool ExecVariableListCodegen::GenerateExecVariableList( // Create the block of (attnum+1)th attribute and jump to it after // you finish with current attribute. next_attribute_block = codegen_utils->CreateBasicBlock( - "attribute_block_"+(attnum+1), ExecVariableList_func); + "attribute_block_"+(attnum+1), exec_variable_list_func); llvm::Value* llvm_next_values_ptr = irb->CreateInBoundsGEP(llvm_slot_PRIVATE_tts_values, @@ -390,9 +396,9 @@ bool ExecVariableListCodegen::GenerateExecVariableList( if (!thisatt->attnotnull) { // Create blocks is_null_block = codegen_utils->CreateBasicBlock( - "is_null_block_"+attnum, ExecVariableList_func); + "is_null_block_"+attnum, exec_variable_list_func); is_not_null_block = codegen_utils->CreateBasicBlock( - "is_not_null_block_"+attnum, ExecVariableList_func); + "is_not_null_block_"+attnum, exec_variable_list_func); llvm::Value* llvm_attnum = codegen_utils->GetConstant(attnum); @@ -400,7 +406,7 @@ bool ExecVariableListCodegen::GenerateExecVariableList( // if (hasnulls && att_isnull(attnum, bp)) {{{ // att_isnull(attnum, bp): !((BITS)[(ATT) >> 3] & (1<<((ATT) & 0x07))) {{ // Expr_1: ((BITS)[(ATT) >> 3] - llvm::Value* llvm_expr_1= irb->CreateLoad(irb->CreateGEP( + llvm::Value* llvm_expr_1 = irb->CreateLoad(irb->CreateGEP( llvm_heaptuple_t_data_t_bits, {codegen_utils->GetConstant(0), irb->CreateAShr(llvm_attnum, codegen_utils->GetConstant(3))})); @@ -458,8 +464,7 @@ bool ExecVariableListCodegen::GenerateExecVariableList( // ---------------- irb->SetInsertPoint(is_not_null_block); - - } // End of if (!thisatt->attnotnull) + } // End of if ( !thisatt->attnotnull ) off = att_align(off, thisatt->attalign); @@ -469,10 +474,9 @@ bool ExecVariableListCodegen::GenerateExecVariableList( {codegen_utils->GetConstant(off)}); llvm::Value* llvm_colVal = nullptr; - if( thisatt->attbyval) { + if (thisatt->attbyval) { // Load the value from the calculated input address. - switch(thisatt->attlen) - { + switch (thisatt->attlen) { case sizeof(char): llvm_colVal = irb->CreateLoad(llvm_next_t_data_ptr); break; @@ -525,7 +529,7 @@ bool ExecVariableListCodegen::GenerateExecVariableList( off += thisatt->attlen; // Process next attribute attribute_block = next_attribute_block; - } // end for + } // end for // Next attribute block // ---------------- @@ -541,7 +545,7 @@ bool ExecVariableListCodegen::GenerateExecVariableList( irb->SetInsertPoint(final_block); // slot->PRIVATE_tts_off = off; - llvm::Value* llvm_slot_PRIVATE_tts_off_ptr /* long* */= + llvm::Value* llvm_slot_PRIVATE_tts_off_ptr /* long* */ = codegen_utils->GetPointerToMember( llvm_slot, &TupleTableSlot::PRIVATE_tts_off); irb->CreateStore(codegen_utils->GetConstant(off), @@ -559,7 +563,7 @@ bool ExecVariableListCodegen::GenerateExecVariableList( // slot->PRIVATE_tts_isnull[attno] = true; // } - // TODO: Convert these to loops + // TODO(shardikar): Convert these to loops llvm::Value* llvm_num_bytes = irb->CreateMul( codegen_utils->GetConstant(sizeof(Datum)), irb->CreateZExtOrTrunc( @@ -568,7 +572,8 @@ bool ExecVariableListCodegen::GenerateExecVariableList( codegen_utils->ir_builder()->CreateCall( llvm_memset, { irb->CreateBitCast( - irb->CreateInBoundsGEP(llvm_slot_PRIVATE_tts_values, {llvm_attno}), + irb->CreateInBoundsGEP(llvm_slot_PRIVATE_tts_values, + {llvm_attno}), codegen_utils->GetType()), codegen_utils->GetConstant(0), llvm_num_bytes}); @@ -576,9 +581,10 @@ bool ExecVariableListCodegen::GenerateExecVariableList( codegen_utils->ir_builder()->CreateCall( llvm_memset, { irb->CreateBitCast( - irb->CreateInBoundsGEP(llvm_slot_PRIVATE_tts_isnull, {llvm_attno}), + irb->CreateInBoundsGEP(llvm_slot_PRIVATE_tts_isnull, + {llvm_attno}), codegen_utils->GetType()), - codegen_utils->GetConstant((int) true), + codegen_utils->GetConstant(static_cast(true)), llvm_num_bytes}); // TupSetVirtualTuple(slot); @@ -590,26 +596,32 @@ bool ExecVariableListCodegen::GenerateExecVariableList( // }}} - // slot_getattr() after calling _slot_getsomeattrs() and remainder of ExecVariableList {{{ + // slot_getattr() after calling _slot_getsomeattrs() and remainder of + // ExecVariableList {{{ // - // This code from ExecVariableList copies the contents of the isnull & values arrays - // in the slot to output variable from the function parameters to ExecVariableList + // This code from ExecVariableList copies the contents of the isnull & values + // arrays in the slot to output variable from the function parameters to + // ExecVariableList int *varNumbers = proj_info_->pi_varNumbers; for (int i = list_length(proj_info_->pi_targetlist) - 1; i >= 0; i--) { // *isnull = slot->PRIVATE_tts_isnull[attnum-1]; llvm::Value* llvm_isnull_from_slot_val = - irb->CreateLoad(irb->CreateInBoundsGEP(llvm_slot_PRIVATE_tts_isnull, - {codegen_utils->GetConstant(varNumbers[i] - 1)})); + irb->CreateLoad(irb->CreateInBoundsGEP( + llvm_slot_PRIVATE_tts_isnull, + {codegen_utils->GetConstant(varNumbers[i] - 1)})); llvm::Value* llvm_isnull_ptr = - irb->CreateInBoundsGEP(llvm_isnull_arg, {codegen_utils->GetConstant(i)}); + irb->CreateInBoundsGEP(llvm_isnull_arg, + {codegen_utils->GetConstant(i)}); irb->CreateStore(llvm_isnull_from_slot_val, llvm_isnull_ptr); // values[i] = slot_getattr(varSlot, varNumber+1, &(isnull[i])); llvm::Value* llvm_value_from_slot_val = - irb->CreateLoad(irb->CreateInBoundsGEP(llvm_slot_PRIVATE_tts_values, - {codegen_utils->GetConstant(varNumbers[i] - 1)})); + irb->CreateLoad(irb->CreateInBoundsGEP( + llvm_slot_PRIVATE_tts_values, + {codegen_utils->GetConstant(varNumbers[i] - 1)})); llvm::Value* llvm_values_ptr = - irb->CreateInBoundsGEP(llvm_values_arg, {codegen_utils->GetConstant(i)}); + irb->CreateInBoundsGEP(llvm_values_arg, + {codegen_utils->GetConstant(i)}); irb->CreateStore(llvm_value_from_slot_val, llvm_values_ptr); } @@ -619,31 +631,37 @@ bool ExecVariableListCodegen::GenerateExecVariableList( // Fall back block // --------------- - // Note: We collect error code information, based on the block from which we fall back, - // and log it for debugging purposes. + // Note: We collect error code information, based on the block from which we + // fall back, and log it for debugging purposes. irb->SetInsertPoint(fallback_block); llvm::PHINode* llvm_error = irb->CreatePHI(codegen_utils->GetType(), 4); - llvm_error->addIncoming(codegen_utils->GetConstant(0), slot_check_block); - llvm_error->addIncoming(codegen_utils->GetConstant(1), tuple_type_check_block); - llvm_error->addIncoming(codegen_utils->GetConstant(2), heap_tuple_check_block); - - elogwrapper.CreateElog(DEBUG1, "Falling back to regular ExecVariableList, reason = %d", llvm_error); + llvm_error->addIncoming(codegen_utils->GetConstant(0), + slot_check_block); + llvm_error->addIncoming(codegen_utils->GetConstant(1), + tuple_type_check_block); + llvm_error->addIncoming(codegen_utils->GetConstant(2), + heap_tuple_check_block); + + elogwrapper.CreateElog( + DEBUG1, + "Falling back to regular ExecVariableList, reason = %d", + llvm_error); codegen_utils->CreateFallback( codegen_utils->RegisterExternalFunction(GetRegularFuncPointer()), - ExecVariableList_func); + exec_variable_list_func); return true; } -bool ExecVariableListCodegen::GenerateCodeInternal(CodegenUtils* codegen_utils) { +bool ExecVariableListCodegen::GenerateCodeInternal( + CodegenUtils* codegen_utils) { bool isGenerated = GenerateExecVariableList(codegen_utils); if (isGenerated) { elog(DEBUG1, "ExecVariableList was generated successfully!"); return true; - } - else { + } else { elog(DEBUG1, "ExecVariableList generation failed!"); return false; } diff --git a/src/backend/codegen/include/codegen/ExecVariableList_codegen.h b/src/backend/codegen/include/codegen/exec_variable_list_codegen.h similarity index 99% rename from src/backend/codegen/include/codegen/ExecVariableList_codegen.h rename to src/backend/codegen/include/codegen/exec_variable_list_codegen.h index d55fe33b0a83dfb6e20577af4b3cd1b903cbcba2..8757529c39cb871dc21b4e2e56f2389219b04b62 100644 --- a/src/backend/codegen/include/codegen/ExecVariableList_codegen.h +++ b/src/backend/codegen/include/codegen/exec_variable_list_codegen.h @@ -3,7 +3,7 @@ // Copyright (C) 2016 Pivotal Software, Inc. // // @filename: -// ExecVariableList_codegen.h +// exec_variable_list.h // // @doc: // Headers for slot_deform_tuple codegen diff --git a/src/backend/codegen/include/codegen/utils/codegen_utils.h b/src/backend/codegen/include/codegen/utils/codegen_utils.h index a2d0a0cd0b6d90c57c0e24eae1bd51ef1d7b7aee..d8b63e93b945ae68af6f0278b7a1baa556f4395a 100644 --- a/src/backend/codegen/include/codegen/utils/codegen_utils.h +++ b/src/backend/codegen/include/codegen/utils/codegen_utils.h @@ -323,7 +323,7 @@ class CodegenUtils { ReturnType (*external_function)(ArgumentTypes..., ...), const std::string& name = "") { return RegisterExternalFunction( - reinterpret_cast(external_function), + reinterpret_cast(external_function), name, true); } @@ -745,11 +745,12 @@ class TypeMaker { // corresponding llvm array types template class TypeMaker { - public: - static llvm::Type* Get(llvm::LLVMContext* context) { - llvm::Type* unit_type = codegen_utils_detail::TypeMaker::Get(context); - return llvm::ArrayType::get(unit_type, N); - } + public: + static llvm::Type* Get(llvm::LLVMContext* context) { + llvm::Type* unit_type = + codegen_utils_detail::TypeMaker::Get(context); + return llvm::ArrayType::get(unit_type, N); + } }; } // namespace codegen_utils_detail @@ -828,7 +829,9 @@ llvm::FunctionType* CodegenUtils::GetFunctionType(const bool is_var_arg) { codegen_utils_detail::TypeVectorBuilder::AppendTypes( this, &argument_types); - return llvm::FunctionType::get(GetType(), argument_types, is_var_arg); + return llvm::FunctionType::get(GetType(), + argument_types, + is_var_arg); } // ---------------------------------------------------------------------------- @@ -1088,7 +1091,6 @@ auto CodegenUtils::GetFunctionPointerImpl(const std::string& function_name) template void CodegenUtils::CreateFallback(llvm::Function* regular_function, llvm::Function* generated_function) { - assert(regular_function != nullptr); assert(generated_function != nullptr); @@ -1100,7 +1102,9 @@ void CodegenUtils::CreateFallback(llvm::Function* regular_function, llvm::CallInst* call_fallback_func = ir_builder()->CreateCall( regular_function, forwarded_args); /* Return the result of the call, or void if the function returns void. */ - if (std::is_same::R, void>::value) { + if (std::is_same::R, + void>::value) { ir_builder()->CreateRetVoid(); } else { ir_builder()->CreateRet(call_fallback_func);