Merge pull request #2301 from Smit-create/flip_sign

PASS: Update FlipSign pass to use Intrinsic Function

integration_tests/CMakeLists.txt

@@ -494,6 +494,7 @@ RUN(NAME expr_19 LABELS cpython llvm c)
 RUN(NAME expr_20 LABELS cpython llvm c)
 RUN(NAME expr_21 LABELS cpython llvm c)
 RUN(NAME expr_22 LABELS cpython llvm c)
+RUN(NAME expr_23 LABELS cpython llvm c)
 
 RUN(NAME expr_01u LABELS cpython llvm c NOFAST)
 RUN(NAME expr_02u LABELS cpython llvm c NOFAST)

integration_tests/expr_23.py

@@ -0,0 +1,23 @@
+from lpython import f32, i32
+
+def flip_sign_check():
+ x: f32
+ eps: f32 = f32(1e-5)
+
+ number: i32 = 123
+ x = f32(5.5)
+
+ if (number%2 == 1):
+ x = -x
+
+ assert abs(x - f32(-5.5)) < eps
+
+ number = 124
+ x = f32(5.5)
+
+ if (number%2 == 1):
+ x = -x
+
+ assert abs(x - f32(5.5)) < eps
+
+flip_sign_check()

src/libasr/pass/flip_sign.cpp

@@ -99,10 +99,10 @@ class FlipSignVisitor : public PassUtils::SkipOptimizationFunctionVisitor<FlipSi
  // xi = xor(shiftl(int(Nd),63), xi)
  LCOMPILERS_ASSERT(flip_sign_signal_variable);
  LCOMPILERS_ASSERT(flip_sign_variable);
- ASR::stmt_t* flip_sign_call = PassUtils::get_flipsign(flip_sign_signal_variable,
- flip_sign_variable, al, unit, pass_options, current_scope,
-  [&](const std::string &msg, const Location &) { throw LCompilersException(msg); });
- pass_result.push_back(al, flip_sign_call);
+ ASR::expr_t* flip_sign_result = PassUtils::get_flipsign(flip_sign_signal_variable,
+ flip_sign_variable, al, unit, x.base.base.loc);
+ pass_result.push_back(al, ASRUtils::STMT(ASR::make_Assignment_t(al, x.base.base.loc,
+  flip_sign_variable, flip_sign_result, nullptr)));
  }
  }
 
@@ -212,6 +212,8 @@ void pass_replace_flip_sign(Allocator &al, ASR::TranslationUnit_t &unit,
  const LCompilers::PassOptions& pass_options) {
  FlipSignVisitor v(al, unit, pass_options);
  v.visit_TranslationUnit(unit);
+ PassUtils::UpdateDependenciesVisitor u(al);
+ u.visit_TranslationUnit(unit);
 }
 
 

src/libasr/pass/intrinsic_function_registry.h

@@ -42,6 +42,7 @@ enum class IntrinsicScalarFunctions : int64_t {
  Exp2,
  Expm1,
  FMA,
+ FlipSign,
  ListIndex,
  Partition,
  ListReverse,
@@ -95,6 +96,7 @@ inline std::string get_intrinsic_name(int x) {
  INTRINSIC_NAME_CASE(Exp2)
  INTRINSIC_NAME_CASE(Expm1)
  INTRINSIC_NAME_CASE(FMA)
+ INTRINSIC_NAME_CASE(FlipSign)
  INTRINSIC_NAME_CASE(ListIndex)
  INTRINSIC_NAME_CASE(Partition)
  INTRINSIC_NAME_CASE(ListReverse)
@@ -1343,6 +1345,86 @@ namespace FMA {
 
 } // namespace FMA
 
+namespace FlipSign {
+
+ static inline void verify_args(const ASR::IntrinsicScalarFunction_t& x, diag::Diagnostics& diagnostics) {
+ ASRUtils::require_impl(x.n_args == 2,
+ "ASR Verify: Call to FlipSign must have exactly 2 arguments",
+ x.base.base.loc, diagnostics);
+ ASR::ttype_t *type1 = ASRUtils::expr_type(x.m_args[0]);
+ ASR::ttype_t *type2 = ASRUtils::expr_type(x.m_args[1]);
+ ASRUtils::require_impl((is_integer(*type1) && is_real(*type2)),
+ "ASR Verify: Arguments to FlipSign must be of int and real type respectively",
+ x.base.base.loc, diagnostics);
+ }
+
+ static ASR::expr_t *eval_FlipSign(Allocator &al, const Location &loc,
+ ASR::ttype_t* t1, Vec<ASR::expr_t*> &args) {
+ int a = ASR::down_cast<ASR::IntegerConstant_t>(args[0])->m_n;
+ double b = ASR::down_cast<ASR::RealConstant_t>(args[1])->m_r;
+ if (a % 2 == 1) b = -b;
+ return make_ConstantWithType(make_RealConstant_t, b, t1, loc);
+ }
+
+ static inline ASR::asr_t* create_FlipSign(Allocator& al, const Location& loc,
+ Vec<ASR::expr_t*>& args,
+ const std::function<void (const std::string &, const Location &)> err) {
+ if (args.size() != 2) {
+ err("Intrinsic FlipSign function accepts exactly 2 arguments", loc);
+ }
+ ASR::ttype_t *type1 = ASRUtils::expr_type(args[0]);
+ ASR::ttype_t *type2 = ASRUtils::expr_type(args[1]);
+ if (!ASRUtils::is_integer(*type1) || !ASRUtils::is_real(*type2)) {
+ err("Argument of the FlipSign function must be int and real respectively",
+ args[0]->base.loc);
+ }
+ ASR::expr_t *m_value = nullptr;
+ if (all_args_evaluated(args)) {
+ Vec<ASR::expr_t*> arg_values; arg_values.reserve(al, 2);
+ arg_values.push_back(al, expr_value(args[0]));
+ arg_values.push_back(al, expr_value(args[1]));
+ m_value = eval_FlipSign(al, loc, expr_type(args[1]), arg_values);
+ }
+ return ASR::make_IntrinsicScalarFunction_t(al, loc,
+ static_cast<int64_t>(IntrinsicScalarFunctions::FlipSign),
+ args.p, args.n, 0, ASRUtils::expr_type(args[1]), m_value);
+ }
+
+ static inline ASR::expr_t* instantiate_FlipSign(Allocator &al, const Location &loc,
+ SymbolTable *scope, Vec<ASR::ttype_t*>& arg_types, ASR::ttype_t *return_type,
+ Vec<ASR::call_arg_t>& new_args, int64_t /*overload_id*/) {
+ declare_basic_variables("_lcompilers_optimization_flipsign_" + type_to_str_python(arg_types[1]));
+ fill_func_arg("signal", arg_types[0]);
+ fill_func_arg("variable", arg_types[1]);
+ auto result = declare(fn_name, return_type, ReturnVar);
+ /*
+ real(real32) function flipsigni32r32(signal, variable)
+ integer(int32), intent(in) :: signal
+ real(real32), intent(out) :: variable
+ integer(int32) :: q
+ q = signal/2
+ flipsigni32r32 = variable
+ if (signal - 2*q == 1 ) flipsigni32r32 = -variable
+ end subroutine
+ */
+
+ ASR::expr_t *two = i(2, arg_types[0]);
+ ASR::expr_t *q = iDiv(args[0], two);
+ ASR::expr_t *cond = iSub(args[0], iMul(two, q));
+ body.push_back(al, b.If(iEq(cond, i(1, arg_types[0])), {
+ b.Assignment(result, f32_neg(args[1], arg_types[1]))
+ }, {
+ b.Assignment(result, args[1])
+ }));
+
+ ASR::symbol_t *f_sym = make_Function_t(fn_name, fn_symtab, dep, args,
+ body, result, Source, Implementation, nullptr);
+ scope->add_symbol(fn_name, f_sym);
+ return b.Call(f_sym, new_args, return_type, nullptr);
+ }
+
+} // namespace FlipSign
+
 #define create_exp_macro(X, stdeval) \
 namespace X { \
  static inline ASR::expr_t* eval_##X(Allocator &al, const Location &loc, \
@@ -2368,6 +2450,8 @@ namespace IntrinsicScalarFunctionRegistry {
  {nullptr, &UnaryIntrinsicFunction::verify_args}},
  {static_cast<int64_t>(IntrinsicScalarFunctions::FMA),
  {&FMA::instantiate_FMA, &FMA::verify_args}},
+ {static_cast<int64_t>(IntrinsicScalarFunctions::FlipSign),
+ {&FlipSign::instantiate_FlipSign, &FMA::verify_args}},
  {static_cast<int64_t>(IntrinsicScalarFunctions::Abs),
  {&Abs::instantiate_Abs, &Abs::verify_args}},
  {static_cast<int64_t>(IntrinsicScalarFunctions::Partition),
@@ -2456,6 +2540,8 @@ namespace IntrinsicScalarFunctionRegistry {
  "exp2"},
  {static_cast<int64_t>(IntrinsicScalarFunctions::FMA),
  "fma"},
+ {static_cast<int64_t>(IntrinsicScalarFunctions::FlipSign),
+ "flipsign"},
  {static_cast<int64_t>(IntrinsicScalarFunctions::Expm1),
  "expm1"},
  {static_cast<int64_t>(IntrinsicScalarFunctions::ListIndex),

src/libasr/pass/pass_utils.cpp

@@ -588,24 +588,25 @@ namespace LCompilers {
  }
 
 
- ASR::stmt_t* get_flipsign(ASR::expr_t* arg0, ASR::expr_t* arg1,
- Allocator& al, ASR::TranslationUnit_t& unit,
- LCompilers::PassOptions& pass_options,
- SymbolTable*& current_scope,
- const std::function<void (const std::string &, const Location &)> err) {
- ASR::symbol_t *v = import_generic_procedure("flipsign", "lfortran_intrinsic_optimization",
- al, unit, pass_options, current_scope, arg0->base.loc);
+ ASR::expr_t* get_flipsign(ASR::expr_t* arg0, ASR::expr_t* arg1,
+ Allocator& al, ASR::TranslationUnit_t& unit, const Location& loc){
+ ASRUtils::impl_function instantiate_function =
+ ASRUtils::IntrinsicScalarFunctionRegistry::get_instantiate_function(
+ static_cast<int64_t>(ASRUtils::IntrinsicScalarFunctions::FlipSign));
+ Vec<ASR::ttype_t*> arg_types;
+ ASR::ttype_t* type = ASRUtils::expr_type(arg1);
+ arg_types.reserve(al, 2);
+ arg_types.push_back(al, ASRUtils::expr_type(arg0));
+ arg_types.push_back(al, ASRUtils::expr_type(arg1));
  Vec<ASR::call_arg_t> args;
  args.reserve(al, 2);
  ASR::call_arg_t arg0_, arg1_;
  arg0_.loc = arg0->base.loc, arg0_.m_value = arg0;
  args.push_back(al, arg0_);
  arg1_.loc = arg1->base.loc, arg1_.m_value = arg1;
  args.push_back(al, arg1_);
- return ASRUtils::STMT(
- ASRUtils::symbol_resolve_external_generic_procedure_without_eval(
- arg0->base.loc, v, args, current_scope, al,
- err));
+ return instantiate_function(al, loc,
+ unit.m_global_scope, arg_types, type, args, 0);
  }
 
  ASR::expr_t* to_int32(ASR::expr_t* x, ASR::ttype_t* int64type, Allocator& al) {

src/libasr/pass/pass_utils.h

@@ -73,12 +73,8 @@ namespace LCompilers {
  ASR::expr_t* get_bound(ASR::expr_t* arr_expr, int dim, std::string bound,
  Allocator& al);
 
-
- ASR::stmt_t* get_flipsign(ASR::expr_t* arg0, ASR::expr_t* arg1,
- Allocator& al, ASR::TranslationUnit_t& unit,
- LCompilers::PassOptions& pass_options,
- SymbolTable*& current_scope,
- const std::function<void (const std::string &, const Location &)> err);
+ ASR::expr_t* get_flipsign(ASR::expr_t* arg0, ASR::expr_t* arg1,
+ Allocator& al, ASR::TranslationUnit_t& unit, const Location& loc);
 
  ASR::expr_t* to_int32(ASR::expr_t* x, ASR::ttype_t* int32type, Allocator& al);