diff --git a/README.rst b/README.rst
index 9d40ab061..ad38f87c2 100644
--- a/README.rst
+++ b/README.rst
@@ -85,7 +85,7 @@ Building on Linux with setuptools
 
     export PYVER=<3.6 or 3.7>
     export NUMPYVER=<1.16 or 1.17>
-    conda create -n sdc-env -q -y -c intel/label/beta -c defaults -c intel -c conda-forge python=$PYVER numpy=$NUMPYVER tbb-devel tbb4py numba=0.53.1 pandas=1.2.0 pyarrow=4.0.1 gcc_linux-64 gxx_linux-64
+    conda create -n sdc-env -q -y -c intel/label/beta -c defaults -c intel -c conda-forge python=$PYVER numpy=$NUMPYVER tbb-devel tbb4py numba=0.54.1 pandas=1.2.0 pyarrow=4.0.1 gcc_linux-64 gxx_linux-64
     source activate sdc-env
     git clone https://github.com/IntelPython/sdc.git
     cd sdc
@@ -123,7 +123,7 @@ Building on Windows with setuptools
 
     set PYVER=<3.6 or 3.7>
     set NUMPYVER=<1.16 or 1.17>
-    conda create -n sdc-env -c intel/label/beta -c defaults -c intel -c conda-forge python=%PYVER% numpy=%NUMPYVER% tbb-devel tbb4py numba=0.53.1 pandas=1.2.0 pyarrow=4.0.1
+    conda create -n sdc-env -c intel/label/beta -c defaults -c intel -c conda-forge python=%PYVER% numpy=%NUMPYVER% tbb-devel tbb4py numba=0.54.1 pandas=1.2.0 pyarrow=4.0.1
     conda activate sdc-env
     set INCLUDE=%INCLUDE%;%CONDA_PREFIX%\Library\include
     set LIB=%LIB%;%CONDA_PREFIX%\Library\lib
diff --git a/azure-pipelines.yml b/azure-pipelines.yml
index a61d1ec94..06f8e43bd 100644
--- a/azure-pipelines.yml
+++ b/azure-pipelines.yml
@@ -31,8 +31,8 @@ jobs:
 
 - template: buildscripts/azure/template-linux-macos.yml
   parameters:
-    name: Ubuntu1604
-    vmImage: ubuntu-16.04
+    name: Ubuntu1804
+    vmImage: ubuntu-18.04
     allowFailure: false
     matrix:
       py3.7_numpy1.17:
diff --git a/conda-recipe/meta.yaml b/conda-recipe/meta.yaml
index 16e552f86..20b9894e8 100644
--- a/conda-recipe/meta.yaml
+++ b/conda-recipe/meta.yaml
@@ -1,4 +1,4 @@
-{% set NUMBA_VERSION = "==0.53.1" %}
+{% set NUMBA_VERSION = "==0.54.1" %}
 {% set PANDAS_VERSION = "==1.2.0" %}
 {% set PYARROW_VERSION = "==4.0.1" %}
 
@@ -33,7 +33,7 @@ requirements:
 
   run:
     - python
-    - numpy
+    - {{ pin_compatible('numpy') }}
     - pandas  {{ PANDAS_VERSION }}
     - pyarrow {{ PYARROW_VERSION }}
     - numba   {{ NUMBA_VERSION }}
diff --git a/requirements.txt b/requirements.txt
index db7518037..b0d0cf72f 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,6 +1,6 @@
 numpy>=1.16
 pandas==1.2.0
 pyarrow==4.0.1
-numba==0.53.1
+numba==0.54.1
 tbb
 tbb-devel
diff --git a/sdc/_str_ext.cpp b/sdc/_str_ext.cpp
index b5e41ce17..f86beee1e 100644
--- a/sdc/_str_ext.cpp
+++ b/sdc/_str_ext.cpp
@@ -32,6 +32,8 @@
 #include <vector>
 #include <cmath>
 #include <algorithm>
+#include <stdexcept>
+#include <limits>
 
 #include "_str_decode.cpp"
 
diff --git a/sdc/cv_ext.py b/sdc/cv_ext.py
index f5dc399cc..a287087f1 100644
--- a/sdc/cv_ext.py
+++ b/sdc/cv_ext.py
@@ -75,7 +75,7 @@ def lower_cv2_imread(context, builder, sig, args):
                             [ll_shty.as_pointer(),
                              lir.IntType(8).as_pointer().as_pointer(),
                              lir.IntType(8).as_pointer()])
-    fn_imread = builder.module.get_or_insert_function(fnty, name="cv_imread")
+    fn_imread = cgutils.get_or_insert_function(builder.module, fnty, name="cv_imread")
     img = builder.call(fn_imread, [shapes_array, data, fname])
 
     return _image_to_array(context, builder, shapes_array, arrtype, data, img)
@@ -99,7 +99,7 @@ def lower_cv2_imread(context, builder, sig, args):
 #                              lir.IntType(8).as_pointer(),
 #                              lir.IntType(64),
 #                              lir.IntType(64)])
-#     fn_resize = builder.module.get_or_insert_function(fnty, name="cv_resize")
+#     fn_resize = cgutils.get_or_insert_function(builder.module, fnty, name="cv_resize")
 #     img = builder.call(fn_resize, [new_sizes[1], new_sizes[0], ary.data, in_array.data,
 #                                     in_shapes[0], in_shapes[1]])
 #
@@ -115,7 +115,7 @@ def _image_to_array(context, builder, shapes_array, arrtype, data, img):
 
     # clean up cv::Mat image
     fnty = lir.FunctionType(lir.VoidType(), [lir.IntType(8).as_pointer()])
-    fn_release = builder.module.get_or_insert_function(fnty, name="cv_mat_release")
+    fn_release = cgutils.get_or_insert_function(builder.module, fnty, name="cv_mat_release")
     builder.call(fn_release, [img])
 
     return impl_ret_new_ref(context, builder, arrtype, ary._getvalue())
@@ -203,7 +203,7 @@ def codegen(context, builder, sig, args):
 
         # clean up image buffer
         fnty = lir.FunctionType(lir.VoidType(), [lir.IntType(8).as_pointer()])
-        fn_release = builder.module.get_or_insert_function(fnty, name="cv_delete_buf")
+        fn_release = cgutils.get_or_insert_function(builder.module, fnty, name="cv_delete_buf")
         builder.call(fn_release, [data])
 
         return impl_ret_new_ref(context, builder, sig.return_type, ary._getvalue())
diff --git a/sdc/datatypes/common_functions.py b/sdc/datatypes/common_functions.py
index fb4c70109..648597cba 100644
--- a/sdc/datatypes/common_functions.py
+++ b/sdc/datatypes/common_functions.py
@@ -455,35 +455,29 @@ def sdc_join_series_indexes_impl(left, right):
     return None
 
 
-@numba.njit
 def _sdc_pandas_format_percentiles(arr):
+    pass
+
+
+@sdc_overload(_sdc_pandas_format_percentiles)
+def _sdc_pandas_format_percentiles_ovld(arr):
     """ Function converting float array of percentiles to a list of strings formatted
         the same as in pandas.io.formats.format.format_percentiles
     """
 
-    percentiles_strs = []
-    for percentile in arr:
-        p_as_string = str(percentile * 100)
+    dtype_precision = numpy.finfo(arr.dtype.key).precision
 
-        trim_index = len(p_as_string) - 1
-        while trim_index >= 0:
-            if p_as_string[trim_index] == '0':
-                trim_index -= 1
-                continue
-            elif p_as_string[trim_index] == '.':
-                break
-
-            trim_index += 1
-            break
-
-        if trim_index < 0:
-            p_as_string_trimmed = '0'
-        else:
-            p_as_string_trimmed = p_as_string[:trim_index]
+    def _sdc_pandas_format_percentiles_impl(arr):
+        percentiles_strs = []
+        for percentile in arr:
+            p_as_string = str(numpy.round(percentile * 100, dtype_precision - 1))
+            p_as_string_trimmed = p_as_string.rstrip('0')
+            p_as_string_trimmed = p_as_string_trimmed.rstrip('.')
+            percentiles_strs.append(p_as_string_trimmed + '%')
 
-        percentiles_strs.append(p_as_string_trimmed + '%')
+        return percentiles_strs
 
-    return percentiles_strs
+    return _sdc_pandas_format_percentiles_impl
 
 
 def sdc_arrays_argsort(A, kind='quicksort'):
diff --git a/sdc/datatypes/hpat_pandas_series_functions.py b/sdc/datatypes/hpat_pandas_series_functions.py
index 24089c5df..83fadfd1f 100644
--- a/sdc/datatypes/hpat_pandas_series_functions.py
+++ b/sdc/datatypes/hpat_pandas_series_functions.py
@@ -4429,7 +4429,7 @@ def hpat_pandas_series_describe_numeric_impl(self, percentiles=None, include=Non
                 sorted_percentiles = sorted(percentiles_list)
 
                 # check percentiles have correct values:
-                arr = numpy.asarray(sorted_percentiles)
+                arr = numpy.asarray(sorted_percentiles).astype(numpy.float64)
                 if len(numpy.unique(arr)) != len(arr):
                     raise ValueError("percentiles cannot contain duplicates")
                 if numpy.any(arr[(arr < 0) * (arr > 1)]):
diff --git a/sdc/distributed_lower.py b/sdc/distributed_lower.py
index 289fa847a..164c74274 100644
--- a/sdc/distributed_lower.py
+++ b/sdc/distributed_lower.py
@@ -89,14 +89,14 @@
 @lower_builtin(distributed_api.get_rank)
 def dist_get_rank(context, builder, sig, args):
     fnty = lir.FunctionType(lir.IntType(32), [])
-    fn = builder.module.get_or_insert_function(fnty, name="hpat_dist_get_rank")
+    fn = cgutils.get_or_insert_function(builder.module, fnty, name="hpat_dist_get_rank")
     return builder.call(fn, [])
 
 
 @lower_builtin(distributed_api.get_size)
 def dist_get_size(context, builder, sig, args):
     fnty = lir.FunctionType(lir.IntType(32), [])
-    fn = builder.module.get_or_insert_function(fnty, name="hpat_dist_get_size")
+    fn = cgutils.get_or_insert_function(builder.module, fnty, name="hpat_dist_get_size")
     return builder.call(fn, [])
 
 
@@ -113,7 +113,7 @@ def dist_get_start(context, builder, sig, args):
 def dist_get_end(context, builder, sig, args):
     fnty = lir.FunctionType(lir.IntType(64), [lir.IntType(64),
                                               lir.IntType(32), lir.IntType(32)])
-    fn = builder.module.get_or_insert_function(fnty, name="hpat_dist_get_end")
+    fn = cgutils.get_or_insert_function(builder.module, fnty, name="hpat_dist_get_end")
     return builder.call(fn, [args[0], args[1], args[2]])
 
 
@@ -163,7 +163,7 @@ def lower_dist_reduce(context, builder, sig, args):
 
     fnty = lir.FunctionType(lir.VoidType(), [lir.IntType(8).as_pointer(),
                                              lir.IntType(8).as_pointer(), op_typ, lir.IntType(32)])
-    fn = builder.module.get_or_insert_function(fnty, name="hpat_dist_reduce")
+    fn = cgutils.get_or_insert_function(builder.module, fnty, name="hpat_dist_reduce")
     builder.call(fn, [in_ptr, out_ptr, args[1], builder.load(typ_arg)])
     # cast back to value type
     out_ptr = builder.bitcast(out_ptr, val_typ.as_pointer())
@@ -206,21 +206,21 @@ def lower_dist_arr_reduce(context, builder, sig, args):
 @lower_builtin(time.time)
 def dist_get_time(context, builder, sig, args):
     fnty = lir.FunctionType(lir.DoubleType(), [])
-    fn = builder.module.get_or_insert_function(fnty, name="hpat_get_time")
+    fn = cgutils.get_or_insert_function(builder.module, fnty, name="hpat_get_time")
     return builder.call(fn, [])
 
 
 @lower_builtin(distributed_api.dist_time)
 def dist_get_dist_time(context, builder, sig, args):
     fnty = lir.FunctionType(lir.DoubleType(), [])
-    fn = builder.module.get_or_insert_function(fnty, name="hpat_dist_get_time")
+    fn = cgutils.get_or_insert_function(builder.module, fnty, name="hpat_dist_get_time")
     return builder.call(fn, [])
 
 
 @lower_builtin(distributed_api.barrier)
 def dist_barrier(context, builder, sig, args):
     fnty = lir.FunctionType(lir.IntType(32), [])
-    fn = builder.module.get_or_insert_function(fnty, name="hpat_barrier")
+    fn = cgutils.get_or_insert_function(builder.module, fnty, name="hpat_barrier")
     return builder.call(fn, [])
 
 
@@ -285,7 +285,7 @@ def lower_dist_irecv(context, builder, sig, args):
                     32), lir.IntType(32), lir.IntType(32),
                 lir.IntType(1)]
     fnty = lir.FunctionType(mpi_req_llvm_type, arg_typs)
-    fn = builder.module.get_or_insert_function(fnty, name="hpat_dist_irecv")
+    fn = cgutils.get_or_insert_function(builder.module, fnty, name="hpat_dist_irecv")
     return builder.call(fn, call_args)
 
 # array, size, pe, tag, cond
@@ -313,14 +313,14 @@ def lower_dist_isend(context, builder, sig, args):
                     32), lir.IntType(32), lir.IntType(32),
                 lir.IntType(1)]
     fnty = lir.FunctionType(mpi_req_llvm_type, arg_typs)
-    fn = builder.module.get_or_insert_function(fnty, name="hpat_dist_isend")
+    fn = cgutils.get_or_insert_function(builder.module, fnty, name="hpat_dist_isend")
     return builder.call(fn, call_args)
 
 
 @lower_builtin(distributed_api.wait, mpi_req_numba_type, types.boolean)
 def lower_dist_wait(context, builder, sig, args):
     fnty = lir.FunctionType(lir.IntType(32), [mpi_req_llvm_type, lir.IntType(1)])
-    fn = builder.module.get_or_insert_function(fnty, name="hpat_dist_wait")
+    fn = cgutils.get_or_insert_function(builder.module, fnty, name="hpat_dist_wait")
     return builder.call(fn, args)
 
 
@@ -328,7 +328,7 @@ def lower_dist_wait(context, builder, sig, args):
 def lower_dist_waitall(context, builder, sig, args):
     fnty = lir.FunctionType(lir.VoidType(),
                             [lir.IntType(32), lir.IntType(8).as_pointer()])
-    fn = builder.module.get_or_insert_function(fnty, name="hpat_dist_waitall")
+    fn = cgutils.get_or_insert_function(builder.module, fnty, name="hpat_dist_waitall")
     builder.call(fn, args)
     return context.get_dummy_value()
 
@@ -425,7 +425,7 @@ def lower_dist_allgather(context, builder, sig, args):
 
     fnty = lir.FunctionType(lir.VoidType(), [lir.IntType(8).as_pointer(),
                                              lir.IntType(32), val_ptr.type, lir.IntType(32)])
-    fn = builder.module.get_or_insert_function(fnty, name="allgather")
+    fn = cgutils.get_or_insert_function(builder.module, fnty, name="allgather")
     builder.call(fn, call_args)
     return context.get_dummy_value()
 
@@ -433,14 +433,14 @@ def lower_dist_allgather(context, builder, sig, args):
 @lower_builtin(distributed_api.comm_req_alloc, types.int32)
 def lower_dist_comm_req_alloc(context, builder, sig, args):
     fnty = lir.FunctionType(lir.IntType(8).as_pointer(), [lir.IntType(32)])
-    fn = builder.module.get_or_insert_function(fnty, name="comm_req_alloc")
+    fn = cgutils.get_or_insert_function(builder.module, fnty, name="comm_req_alloc")
     return builder.call(fn, args)
 
 
 @lower_builtin(distributed_api.comm_req_dealloc, req_array_type)
 def lower_dist_comm_req_dealloc(context, builder, sig, args):
     fnty = lir.FunctionType(lir.VoidType(), [lir.IntType(8).as_pointer()])
-    fn = builder.module.get_or_insert_function(fnty, name="comm_req_dealloc")
+    fn = cgutils.get_or_insert_function(builder.module, fnty, name="comm_req_dealloc")
     builder.call(fn, args)
     return context.get_dummy_value()
 
@@ -471,7 +471,7 @@ def setitem_req_array(context, builder, sig, args):
 #                       wraparound=False):
 #         # get local index or -1 if out of bounds
 #         fnty = lir.FunctionType(lir.IntType(64), [lir.IntType(64), lir.IntType(64), lir.IntType(64)])
-#         fn = builder.module.get_or_insert_function(fnty, name="hpat_dist_get_item_pointer")
+#         fn = cgutils.get_or_insert_function(builder.module, fnty, name="hpat_dist_get_item_pointer")
 #         first_ind = builder.call(fn, [inds[0], start, count])
 #         inds = tuple([first_ind, *inds[1:]])
 #         # regular local pointer with new indices
@@ -481,7 +481,7 @@ def setitem_req_array(context, builder, sig, args):
 #         not_inbound = builder.icmp_signed('==', first_ind, lir.Constant(lir.IntType(64), -1))
 #         # get dummy pointer
 #         dummy_fnty  = lir.FunctionType(lir.IntType(8).as_pointer(), [])
-#         dummy_fn = builder.module.get_or_insert_function(dummy_fnty, name="hpat_get_dummy_ptr")
+#         dummy_fn = cgutils.get_or_insert_function(builder.module, dummy_fnty, name="hpat_get_dummy_ptr")
 #         dummy_ptr = builder.bitcast(builder.call(dummy_fn, []), in_ptr.type)
 #         with builder.if_then(not_inbound, likely=True):
 #             builder.store(dummy_ptr, ret_ptr)
@@ -613,7 +613,7 @@ def generic(self, args, kws):
 @lower_builtin(hpat_finalize)
 def lower_hpat_finalize(context, builder, sig, args):
     fnty = lir.FunctionType(lir.IntType(32), [])
-    fn = builder.module.get_or_insert_function(fnty, name="hpat_finalize")
+    fn = cgutils.get_or_insert_function(builder.module, fnty, name="hpat_finalize")
     return builder.call(fn, args)
 
 
diff --git a/sdc/extensions/indexes/int64_index_ext.py b/sdc/extensions/indexes/int64_index_ext.py
index 6a22c11e7..40ad516d2 100644
--- a/sdc/extensions/indexes/int64_index_ext.py
+++ b/sdc/extensions/indexes/int64_index_ext.py
@@ -40,7 +40,7 @@
 
 from sdc.datatypes.indexes import *
 from sdc.utilities.sdc_typing_utils import SDCLimitation
-from sdc.utilities.utils import sdc_overload, sdc_overload_attribute, sdc_overload_method, BooleanLiteral
+from sdc.utilities.utils import sdc_overload, sdc_overload_attribute, sdc_overload_method
 from sdc.utilities.sdc_typing_utils import (
         TypeChecker,
         check_signed_integer,
@@ -388,10 +388,12 @@ def pd_int64_index_is_overload(context, builder, sig, args):
     if ty_lhs != ty_rhs:
         return cgutils.false_bit
 
+    # llvmlite passes LiteralStructs into functions as separate fields
+    # and there's no way to get pointer to original struct (where it's allocated)
+    # other than walk through chain of instruction operands to alloca instruction
+    # so just check if the instructions themselves match exactly
     lhs, rhs = args
-    lhs_ptr = builder.ptrtoint(lhs.operands[0], cgutils.intp_t)
-    rhs_ptr = builder.ptrtoint(rhs.operands[0], cgutils.intp_t)
-    return builder.icmp_signed('==', lhs_ptr, rhs_ptr)
+    return context.get_constant(types.bool_, lhs == rhs)
 
 
 @lower_builtin('getiter', Int64IndexType)
@@ -543,7 +545,7 @@ def pd_int64_index_join_overload(self, other, how, level=None, return_indexers=F
     if not (isinstance(level, (types.Omitted, types.NoneType)) or level is None):
         ty_checker.raise_exc(level, 'None', 'level')
 
-    if not (isinstance(return_indexers, (types.Omitted, BooleanLiteral)) or return_indexers is False):
+    if not (isinstance(return_indexers, (types.Omitted, types.BooleanLiteral)) or return_indexers is False):
         ty_checker.raise_exc(return_indexers, 'boolean', 'return_indexers')
 
     if not (isinstance(sort, (types.Omitted, types.Boolean)) or sort is False):
diff --git a/sdc/extensions/indexes/multi_index_ext.py b/sdc/extensions/indexes/multi_index_ext.py
index 8943b9e6a..f2b91ffb3 100644
--- a/sdc/extensions/indexes/multi_index_ext.py
+++ b/sdc/extensions/indexes/multi_index_ext.py
@@ -42,7 +42,7 @@
 
 from sdc.datatypes.indexes import *
 from sdc.utilities.sdc_typing_utils import SDCLimitation
-from sdc.utilities.utils import sdc_overload, sdc_overload_attribute, sdc_overload_method, BooleanLiteral
+from sdc.utilities.utils import sdc_overload, sdc_overload_attribute, sdc_overload_method
 from sdc.utilities.sdc_typing_utils import (
         TypeChecker,
         sdc_pandas_index_types,
@@ -759,10 +759,9 @@ def pd_multi_index_is_overload(context, builder, sig, args):
     if ty_lhs != ty_rhs:
         return cgutils.false_bit
 
+    # similar to Int64Index (compare instructions building index structs)
     lhs, rhs = args
-    lhs_ptr = builder.ptrtoint(lhs.operands[0], cgutils.intp_t)
-    rhs_ptr = builder.ptrtoint(rhs.operands[0], cgutils.intp_t)
-    return builder.icmp_signed('==', lhs_ptr, rhs_ptr)
+    return context.get_constant(types.bool_, lhs == rhs)
 
 
 @lower_builtin('getiter', MultiIndexType)
diff --git a/sdc/extensions/indexes/positional_index_ext.py b/sdc/extensions/indexes/positional_index_ext.py
index 2c512d4fe..337c54675 100644
--- a/sdc/extensions/indexes/positional_index_ext.py
+++ b/sdc/extensions/indexes/positional_index_ext.py
@@ -40,7 +40,7 @@
 from sdc.datatypes.indexes import PositionalIndexType, RangeIndexType
 from sdc.datatypes.indexes.range_index_type import RangeIndexDataType
 from sdc.utilities.sdc_typing_utils import SDCLimitation
-from sdc.utilities.utils import sdc_overload, sdc_overload_attribute, sdc_overload_method, BooleanLiteral
+from sdc.utilities.utils import sdc_overload, sdc_overload_attribute, sdc_overload_method
 from sdc.extensions.indexes.range_index_ext import box_range_index, unbox_range_index
 from sdc.utilities.sdc_typing_utils import (
                                 TypeChecker,
@@ -300,10 +300,9 @@ def pd_positional_index_is_overload(context, builder, sig, args):
     if ty_lhs != ty_rhs:
         return cgutils.false_bit
 
+    # similar to Int64Index (compare instructions building index structs)
     lhs, rhs = args
-    lhs_ptr = builder.ptrtoint(lhs.operands[0], cgutils.intp_t)
-    rhs_ptr = builder.ptrtoint(rhs.operands[0], cgutils.intp_t)
-    return builder.icmp_signed('==', lhs_ptr, rhs_ptr)
+    return context.get_constant(types.bool_, lhs == rhs)
 
 
 @lower_builtin('getiter', PositionalIndexType)
@@ -433,7 +432,7 @@ def pd_positional_index_join_overload(self, other, how, level=None, return_index
     if not (isinstance(level, (types.Omitted, types.NoneType)) or level is None):
         ty_checker.raise_exc(level, 'None', 'level')
 
-    if not (isinstance(return_indexers, (types.Omitted, BooleanLiteral)) or return_indexers is False):
+    if not (isinstance(return_indexers, (types.Omitted, types.BooleanLiteral)) or return_indexers is False):
         ty_checker.raise_exc(return_indexers, 'boolean', 'return_indexers')
 
     if not (isinstance(sort, (types.Omitted, types.Boolean)) or sort is False):
diff --git a/sdc/extensions/indexes/range_index_ext.py b/sdc/extensions/indexes/range_index_ext.py
index 44fdafa69..da328073f 100644
--- a/sdc/extensions/indexes/range_index_ext.py
+++ b/sdc/extensions/indexes/range_index_ext.py
@@ -40,7 +40,7 @@
 from sdc.datatypes.indexes import PositionalIndexType, RangeIndexType
 from sdc.datatypes.indexes.range_index_type import RangeIndexDataType
 from sdc.utilities.sdc_typing_utils import SDCLimitation
-from sdc.utilities.utils import sdc_overload, sdc_overload_attribute, sdc_overload_method, BooleanLiteral
+from sdc.utilities.utils import sdc_overload, sdc_overload_attribute, sdc_overload_method
 from sdc.utilities.sdc_typing_utils import (
                                     TypeChecker,
                                     check_signed_integer,
@@ -455,10 +455,9 @@ def pd_range_index_is_overload(context, builder, sig, args):
     if ty_lhs != ty_rhs:
         return cgutils.false_bit
 
+    # similar to Int64Index (compare instructions building index structs)
     lhs, rhs = args
-    lhs_ptr = builder.ptrtoint(lhs.operands[0], cgutils.intp_t)
-    rhs_ptr = builder.ptrtoint(rhs.operands[0], cgutils.intp_t)
-    return builder.icmp_signed('==', lhs_ptr, rhs_ptr)
+    return context.get_constant(types.bool_, lhs == rhs)
 
 
 @lower_builtin('getiter', RangeIndexType)
@@ -603,7 +602,7 @@ def pd_range_index_join_overload(self, other, how, level=None, return_indexers=F
     if not (isinstance(level, (types.Omitted, types.NoneType)) or level is None):
         ty_checker.raise_exc(level, 'None', 'level')
 
-    if not (isinstance(return_indexers, (types.Omitted, BooleanLiteral)) or return_indexers is False):
+    if not (isinstance(return_indexers, (types.Omitted, types.BooleanLiteral)) or return_indexers is False):
         ty_checker.raise_exc(return_indexers, 'boolean', 'return_indexers')
 
     if not (isinstance(sort, (types.Omitted, types.Boolean)) or sort is False):
diff --git a/sdc/extensions/sdc_hashmap_ext.py b/sdc/extensions/sdc_hashmap_ext.py
index d02840035..f4ded0155 100644
--- a/sdc/extensions/sdc_hashmap_ext.py
+++ b/sdc/extensions/sdc_hashmap_ext.py
@@ -31,7 +31,6 @@
 import operator
 import sdc
 
-from sdc import hstr_ext
 from glob import glob
 from llvmlite import ir as lir
 from numba import types, cfunc
@@ -44,15 +43,9 @@
 from numba.cpython.listobj import ListInstance
 from numba.core.typing.templates import (infer_global, AbstractTemplate, infer,
                                          signature, AttributeTemplate, infer_getattr, bound_function)
-from numba import prange
-
-from sdc.str_ext import string_type
-from sdc.str_arr_type import (StringArray, string_array_type, StringArrayType,
-                              StringArrayPayloadType, str_arr_payload_type, StringArrayIterator,
-                              is_str_arr_typ, offset_typ, data_ctypes_type, offset_ctypes_type)
-from sdc.utilities.sdc_typing_utils import check_is_array_of_dtype
-
 from numba.typed.typedobjectutils import _as_bytes
+
+from sdc.str_arr_type import StringArrayType
 from sdc import hconc_dict
 from sdc.extensions.sdc_hashmap_type import (ConcurrentDict, ConcurrentDictType,
                                              ConcDictKeysIterableType, ConcDictIteratorType,
@@ -319,7 +312,7 @@ def codegen(context, builder, sig, args):
                                  llptrtype, llptrtype,                # val incref, decref
                                  lir.IntType(64), lir.IntType(64)])   # key size, val size
         func_name = f"hashmap_create_{key_type_postfix}_to_{value_type_postfix}"
-        fn_hashmap_create = builder.module.get_or_insert_function(
+        fn_hashmap_create = cgutils.get_or_insert_function(builder.module,
             fnty, name=func_name)
 
         gen_key = context.get_constant(types.int8, types.int8(not key_numeric))
@@ -403,7 +396,7 @@ def codegen(context, builder, sig, args):
         fnty = lir.FunctionType(lir.IntType(64),
                                 [lir.IntType(8).as_pointer()])
         func_name = f"hashmap_size_{key_type_postfix}_to_{value_type_postfix}"
-        fn_hashmap_size = builder.module.get_or_insert_function(
+        fn_hashmap_size = cgutils.get_or_insert_function(builder.module,
             fnty, name=func_name)
         ret = builder.call(fn_hashmap_size, [cdict.data_ptr])
         return ret
@@ -441,7 +434,7 @@ def codegen(context, builder, sig, args):
                                  lir_val_type])
 
         func_name = f"hashmap_set_{key_type_postfix}_to_{value_type_postfix}"
-        fn_hashmap_insert = builder.module.get_or_insert_function(
+        fn_hashmap_insert = cgutils.get_or_insert_function(builder.module,
             fnty, name=func_name)
 
         builder.call(fn_hashmap_insert, [cdict.data_ptr, key_val, val_val])
@@ -483,7 +476,7 @@ def codegen(context, builder, sig, args):
                                 [lir.IntType(8).as_pointer(),
                                  lir_key_type])
         func_name = f"hashmap_contains_{key_type_postfix}_to_{value_type_postfix}"
-        fn_hashmap_contains = builder.module.get_or_insert_function(
+        fn_hashmap_contains = cgutils.get_or_insert_function(builder.module,
             fnty, name=func_name)
 
         res = builder.call(fn_hashmap_contains, [cdict.data_ptr, key_val])
@@ -527,7 +520,7 @@ def codegen(context, builder, sig, args):
                                  lir_value_type.as_pointer()
                                  ])
         func_name = f"hashmap_lookup_{key_type_postfix}_to_{value_type_postfix}"
-        fn_hashmap_lookup = builder.module.get_or_insert_function(
+        fn_hashmap_lookup = cgutils.get_or_insert_function(builder.module,
             fnty, name=func_name)
 
         status = builder.call(fn_hashmap_lookup, [cdict.data_ptr, key_val, native_value_ptr])
@@ -593,7 +586,7 @@ def codegen(context, builder, sig, args):
         fnty = lir.FunctionType(lir.VoidType(),
                                 [lir.IntType(8).as_pointer()])
         func_name = f"hashmap_clear_{key_type_postfix}_to_{value_type_postfix}"
-        fn_hashmap_clear = builder.module.get_or_insert_function(
+        fn_hashmap_clear = cgutils.get_or_insert_function(builder.module,
             fnty, name=func_name)
         builder.call(fn_hashmap_clear, [cdict.data_ptr])
         return
@@ -675,7 +668,7 @@ def codegen(context, builder, sig, args):
                                  llvoidptr,
                                  ])
         func_name = f"hashmap_pop_{key_type_postfix}_to_{value_type_postfix}"
-        fn_hashmap_pop = builder.module.get_or_insert_function(
+        fn_hashmap_pop = cgutils.get_or_insert_function(builder.module,
             fnty, name=func_name)
 
         status = builder.call(fn_hashmap_pop, [cdict.data_ptr, key_val, ret_val_ptr])
@@ -759,7 +752,7 @@ def codegen(context, builder, sig, args):
                                  lir.IntType(8).as_pointer()
                                  ])
         func_name = f"hashmap_update_{key_type_postfix}_to_{value_type_postfix}"
-        fn_hashmap_update = builder.module.get_or_insert_function(
+        fn_hashmap_update = cgutils.get_or_insert_function(builder.module,
             fnty, name=func_name)
 
         builder.call(fn_hashmap_update, [self_cdict.data_ptr, other_cdict.data_ptr])
@@ -835,7 +828,7 @@ def codegen(context, builder, sig, args):
                                  lir.IntType(64),                    # size
                                  ])
         func_name = f"hashmap_create_from_data_{key_type_postfix}_to_{value_type_postfix}"
-        fn_hashmap_create = builder.module.get_or_insert_function(
+        fn_hashmap_create = cgutils.get_or_insert_function(builder.module,
             fnty, name=func_name)
         builder.call(fn_hashmap_create,
                      [cdict._get_ptr_by_name('meminfo'),
@@ -913,7 +906,7 @@ def codegen(context, builder, sig, args):
         fnty = lir.FunctionType(lir.VoidType(),
                                 [lir.IntType(8).as_pointer()])
         func_name = f"hashmap_dump_{key_type_postfix}_to_{value_type_postfix}"
-        fn_hashmap_dump = builder.module.get_or_insert_function(
+        fn_hashmap_dump = cgutils.get_or_insert_function(builder.module,
             fnty, name=func_name)
         builder.call(fn_hashmap_dump, [cdict.data_ptr])
         return
@@ -1018,7 +1011,7 @@ def call_native_getiter(context, builder, dict_type, dict_val, it):
                              llvoidptr,
                              llvoidptr])
     func_name = f"hashmap_getiter_{key_type_postfix}_to_{value_type_postfix}"
-    fn_hashmap_getiter = builder.module.get_or_insert_function(
+    fn_hashmap_getiter = cgutils.get_or_insert_function(builder.module,
         fnty, name=func_name)
 
     cdict = cgutils.create_struct_proxy(dict_type)(context, builder, value=dict_val)
@@ -1085,7 +1078,7 @@ def impl_iterator_iternext(context, builder, sig, args, result):
                              lir_key_type.as_pointer(),
                              lir_value_type.as_pointer()])
     func_name = f"hashmap_iternext_{key_type_postfix}_to_{value_type_postfix}"
-    fn_hashmap_iternext = builder.module.get_or_insert_function(
+    fn_hashmap_iternext = cgutils.get_or_insert_function(builder.module,
         fnty, name=func_name)
 
     iter_ctinfo = context.make_helper(builder, iter_type, iter_val)
diff --git a/sdc/functions/numpy_like.py b/sdc/functions/numpy_like.py
index 96d1f0a5c..0e8c640ac 100644
--- a/sdc/functions/numpy_like.py
+++ b/sdc/functions/numpy_like.py
@@ -1120,6 +1120,9 @@ def sdc_array_equal_overload(A, B):
 
     if (A == string_array_type and A == B):
         def sdc_array_equal_str_arr_impl(A, B):
+            if A is B:
+                return True
+
             is_index_equal = (len(A) == len(B)
                               and num_total_chars(A) == num_total_chars(B))
             for i in numpy.arange(len(A)):
@@ -1132,6 +1135,9 @@ def sdc_array_equal_str_arr_impl(A, B):
     else:
 
         def sdc_array_equal_impl(A, B):
+            if A is B:
+                return True
+
             if len(A) != len(B):
                 return False
             # FIXME_Numba#5157: change to simple A == B when issue is resolved
diff --git a/sdc/hiframes/pd_series_type.py b/sdc/hiframes/pd_series_type.py
index 569df88a3..8451074cd 100644
--- a/sdc/hiframes/pd_series_type.py
+++ b/sdc/hiframes/pd_series_type.py
@@ -32,7 +32,7 @@
 from numba.core import cgutils
 from numba.np.numpy_support import from_dtype
 from numba.extending import (models, register_model, make_attribute_wrapper, lower_builtin)
-from numba.core.imputils import (impl_ret_new_ref, iternext_impl, RefType)
+from numba.core.imputils import (impl_ret_untracked, call_getiter, iternext_impl, RefType)
 from numba.np.arrayobj import make_array, _getitem_array_single_int
 
 from sdc.str_ext import string_type, list_string_array_type
@@ -181,30 +181,10 @@ def getiter_series(context, builder, sig, args):
     :return: reference to iterator
     """
 
-    arraytype = sig.args[0].data
-
-    # Create instruction to get array to iterate
-    zero_member_pointer = context.get_constant(types.intp, 0)
-    zero_member = context.get_constant(types.int32, 0)
-    alloca = args[0].operands[0]
-    gep_result = builder.gep(alloca, [zero_member_pointer, zero_member])
-    array = builder.load(gep_result)
-
-    # TODO: call numba getiter with gep_result for array
-    iterobj = context.make_helper(builder, sig.return_type)
-    zero_index = context.get_constant(types.intp, 0)
-    indexptr = cgutils.alloca_once_value(builder, zero_index)
-
-    iterobj.index = indexptr
-    iterobj.array = array
-
-    if context.enable_nrt:
-        context.nrt.incref(builder, arraytype, array)
-
-    result = iterobj._getvalue()
-    # Note: a decref on the iterator will dereference all internal MemInfo*
-    out = impl_ret_new_ref(context, builder, sig.return_type, result)
-    return out
+    (value,) = args
+    series_obj = cgutils.create_struct_proxy(sig.args[0])(context, builder, value)
+    res = call_getiter(context, builder, sig.args[0].data, series_obj.data)
+    return impl_ret_untracked(context, builder, SeriesType, res)
 
 
 # TODO: call it from numba.np.arrayobj, need separate function in numba
diff --git a/sdc/io/parquet_pio.py b/sdc/io/parquet_pio.py
index 224ffc245..2ba128adf 100644
--- a/sdc/io/parquet_pio.py
+++ b/sdc/io/parquet_pio.py
@@ -352,7 +352,7 @@ def generic(self, args, kws):
 def pq_size_lower(context, builder, sig, args):
     fnty = lir.FunctionType(lir.IntType(64),
                             [lir.IntType(8).as_pointer(), lir.IntType(64)])
-    fn = builder.module.get_or_insert_function(fnty, name="pq_get_size")
+    fn = cgutils.get_or_insert_function(builder.module, fnty, name="pq_get_size")
     return builder.call(fn, args)
 
 
@@ -363,7 +363,7 @@ def pq_read_lower(context, builder, sig, args):
                              lir.IntType(8).as_pointer()], lir.IntType(32))
     out_array = make_array(sig.args[2])(context, builder, args[2])
 
-    fn = builder.module.get_or_insert_function(fnty, name="pq_read")
+    fn = cgutils.get_or_insert_function(builder.module, fnty, name="pq_read")
     return builder.call(fn, [args[0], args[1],
                              builder.bitcast(
                                  out_array.data, lir.IntType(8).as_pointer()),
@@ -385,7 +385,7 @@ def pq_read_parallel_lower(context, builder, sig, args):
                              lir.IntType(32), lir.IntType(64), lir.IntType(64)])
     out_array = make_array(sig.args[2])(context, builder, args[2])
 
-    fn = builder.module.get_or_insert_function(fnty, name="pq_read_parallel")
+    fn = cgutils.get_or_insert_function(builder.module, fnty, name="pq_read_parallel")
     return builder.call(fn, [args[0], args[1],
                              builder.bitcast(
                                  out_array.data, lir.IntType(8).as_pointer()),
@@ -411,7 +411,7 @@ def pq_read_string_lower(context, builder, sig, args):
                              lir.IntType(8).as_pointer().as_pointer(),
                              lir.IntType(8).as_pointer().as_pointer()])
 
-    fn = builder.module.get_or_insert_function(fnty, name="pq_read_string")
+    fn = cgutils.get_or_insert_function(builder.module, fnty, name="pq_read_string")
     res = builder.call(fn, [args[0], args[1],
                             str_arr_payload._get_ptr_by_name('offsets'),
                             str_arr_payload._get_ptr_by_name('data'),
@@ -444,7 +444,7 @@ def pq_read_string_parallel_lower(context, builder, sig, args):
                              lir.IntType(8).as_pointer().as_pointer(),
                              lir.IntType(64), lir.IntType(64)])
 
-    fn = builder.module.get_or_insert_function(
+    fn = cgutils.get_or_insert_function(builder.module,
         fnty, name="pq_read_string_parallel")
     res = builder.call(fn, [args[0], args[1],
                             str_arr_payload._get_ptr_by_name('offsets'),
diff --git a/sdc/set_ext.py b/sdc/set_ext.py
index 1223c637a..380d9ab2d 100644
--- a/sdc/set_ext.py
+++ b/sdc/set_ext.py
@@ -186,7 +186,7 @@ def generic(self, args, kws):
 def lower_dict_in(context, builder, sig, args):
     fnty = lir.FunctionType(lir.IntType(1), [lir.IntType(8).as_pointer(),
                                              lir.IntType(8).as_pointer()])
-    fn = builder.module.get_or_insert_function(fnty, name="set_in_string")
+    fn = cgutils.get_or_insert_function(builder.module, fnty, name="set_in_string")
     return builder.call(fn, args)
 
 
@@ -196,7 +196,7 @@ def lower_dict_in_op(context, builder, sig, args):
     char_str = gen_get_unicode_chars(context, builder, unicode_str)
     fnty = lir.FunctionType(lir.IntType(1), [lir.IntType(8).as_pointer(),
                                              lir.IntType(8).as_pointer()])
-    fn = builder.module.get_or_insert_function(fnty, name="set_in_string")
+    fn = cgutils.get_or_insert_function(builder.module, fnty, name="set_in_string")
     return builder.call(fn, [char_str, set_str])
 
 
@@ -230,8 +230,9 @@ def codegen(context, builder, sig, args):
                                  lir.IntType(32).as_pointer(),
                                  lir.IntType(8).as_pointer(),
                                  ])
-        fn_getitem = builder.module.get_or_insert_function(fnty,
-                                                           name="populate_str_arr_from_set")
+        fn_getitem = cgutils.get_or_insert_function(builder.module,
+                                                    fnty,
+                                                    name="populate_str_arr_from_set")
         builder.call(fn_getitem, [in_set, string_array.offsets,
                                   string_array.data])
         return context.get_dummy_value()
@@ -253,7 +254,7 @@ def __init__(self, dmm, fe_type):
 def getiter_set(context, builder, sig, args):
     fnty = lir.FunctionType(lir.IntType(8).as_pointer(),
                             [lir.IntType(8).as_pointer()])
-    fn = builder.module.get_or_insert_function(fnty, name="set_iterator_string")
+    fn = cgutils.get_or_insert_function(builder.module, fnty, name="set_iterator_string")
     itp = builder.call(fn, args)
 
     iterobj = context.make_helper(builder, sig.return_type)
@@ -273,13 +274,13 @@ def iternext_setiter(context, builder, sig, args, result):
 
     fnty = lir.FunctionType(lir.IntType(1),
                             [lir.IntType(8).as_pointer(), lir.IntType(8).as_pointer()])
-    fn = builder.module.get_or_insert_function(fnty, name="set_itervalid_string")
+    fn = cgutils.get_or_insert_function(builder.module, fnty, name="set_itervalid_string")
     is_valid = builder.call(fn, [iterobj.itp, iterobj.set])
     result.set_valid(is_valid)
 
     fnty = lir.FunctionType(lir.IntType(8).as_pointer(),
                             [lir.IntType(8).as_pointer()])
-    fn = builder.module.get_or_insert_function(fnty, name="set_nextval_string")
+    fn = cgutils.get_or_insert_function(builder.module, fnty, name="set_nextval_string")
     kind = numba.cpython.unicode.PY_UNICODE_1BYTE_KIND
 
     def std_str_to_unicode(std_str):
diff --git a/sdc/str_arr_ext.py b/sdc/str_arr_ext.py
index e929785f5..63702ad79 100644
--- a/sdc/str_arr_ext.py
+++ b/sdc/str_arr_ext.py
@@ -45,6 +45,7 @@
 from numba.cpython.listobj import ListInstance
 from numba.core.typing.templates import (infer_global, AbstractTemplate, infer,
                                          signature, AttributeTemplate, infer_getattr, bound_function)
+from numba.np import arrayobj
 from numba import prange
 
 from sdc.str_ext import string_type
@@ -154,7 +155,7 @@ def __init__(self, dmm, fe_type):
         super(StrArrayIteratorModel, self).__init__(dmm, fe_type, members)
 
 
-lower_builtin('getiter', string_array_type)(numba.np.arrayobj.getiter_array)
+lower_builtin('getiter', string_array_type)(arrayobj.getiter_array)
 lower_builtin('iternext', StringArrayIterator)(iternext_impl(RefType.NEW)(iternext_str_array))
 
 
@@ -577,7 +578,7 @@ def construct_string_array(context, builder):
     llsize = context.get_value_type(types.uintp)
     dtor_ftype = lir.FunctionType(lir.VoidType(),
                                   [llvoidptr, llsize, llvoidptr])
-    dtor_fn = builder.module.get_or_insert_function(
+    dtor_fn = cgutils.get_or_insert_function(builder.module,
         dtor_ftype, name="dtor_string_array")
 
     meminfo = context.nrt.meminfo_alloc_dtor(
@@ -688,7 +689,7 @@ def str_arr_from_sequence(in_list):
 #     # get total size of string buffer
 #     fnty = lir.FunctionType(lir.IntType(64),
 #                             [lir.IntType(8).as_pointer()])
-#     fn_len = builder.module.get_or_insert_function(fnty, name="get_str_len")
+#     fn_len = cgutils.get_or_insert_function(builder.module, fnty, name="get_str_len")
 #     total_size = cgutils.alloca_once_value(builder, zero)
 
 #     # loop through all strings and get length
@@ -758,8 +759,8 @@ def codegen(context, builder, sig, args):
                                  lir.IntType(8).as_pointer().as_pointer(),
                                  lir.IntType(64),
                                  lir.IntType(64)])
-        fn_alloc = builder.module.get_or_insert_function(fnty,
-                                                         name="allocate_string_array")
+
+        fn_alloc = cgutils.get_or_insert_function(builder.module, fnty, name="allocate_string_array")
         builder.call(fn_alloc, [str_arr_payload._get_ptr_by_name('offsets'),
                                 str_arr_payload._get_ptr_by_name('data'),
                                 str_arr_payload._get_ptr_by_name('null_bitmap'),
@@ -803,8 +804,9 @@ def codegen(context, builder, sig, args):
                                  lir.IntType(64),
                                  lir.IntType(64),
                                  lir.IntType(64), ])
-        fn_alloc = builder.module.get_or_insert_function(fnty,
-                                                         name="set_string_array_range")
+        fn_alloc = cgutils.get_or_insert_function(builder.module,
+                                                  fnty,
+                                                  name="set_string_array_range")
         builder.call(fn_alloc, [out_string_array.offsets,
                                 out_string_array.data,
                                 in_string_array.offsets,
@@ -833,7 +835,7 @@ def box_str_arr(typ, val, c):
                              lir.IntType(8).as_pointer(),
                              lir.IntType(8).as_pointer(),
                              ])
-    fn_get = c.builder.module.get_or_insert_function(fnty, name="np_array_from_string_array")
+    fn_get = cgutils.get_or_insert_function(c.builder.module, fnty, name="np_array_from_string_array")
     arr = c.builder.call(fn_get, [string_array.num_items, string_array.offsets,
                                   string_array.data, string_array.null_bitmap])
 
@@ -923,7 +925,7 @@ def setitem_str_arr(context, builder, sig, args):
                              lir.IntType(32),
                              lir.IntType(32),
                              lir.IntType(64)])
-    fn_setitem = builder.module.get_or_insert_function(
+    fn_setitem = cgutils.get_or_insert_function(builder.module,
         fnty, name="setitem_string_array")
     builder.call(fn_setitem, [string_array.offsets, string_array.data,
                               string_array.num_total_chars,
@@ -953,7 +955,7 @@ def codegen(context, builder, sig, args):
                                  lir.IntType(32),
                                  lir.IntType(32),
                                  lir.IntType(64)])
-        fn_setitem = builder.module.get_or_insert_function(
+        fn_setitem = cgutils.get_or_insert_function(builder.module,
             fnty, name="setitem_string_array")
         # kind doesn't matter since input is ASCII
         kind = context.get_constant(types.int32, -1)
@@ -971,8 +973,9 @@ def lower_is_na(context, builder, bull_bitmap, ind):
     fnty = lir.FunctionType(lir.IntType(1),
                             [lir.IntType(8).as_pointer(),
                              lir.IntType(64)])
-    fn_getitem = builder.module.get_or_insert_function(fnty,
-                                                       name="is_na")
+    fn_getitem = cgutils.get_or_insert_function(builder.module,
+                                                fnty,
+                                                name="is_na")
     return builder.call(fn_getitem, [bull_bitmap,
                                      ind])
 
@@ -1053,7 +1056,7 @@ def codegen(context, builder, sig, args):
                                                  lir.IntType(64).as_pointer(),
                                                  uni_str.meminfo.type.as_pointer(),
                                                  lir.IntType(8).as_pointer()])
-        fn_decode = builder.module.get_or_insert_function(
+        fn_decode = cgutils.get_or_insert_function(builder.module,
             fnty, name="decode_utf8")
         builder.call(fn_decode, [ptr, length,
                                  uni_str._get_ptr_by_name('kind'),
@@ -1172,7 +1175,7 @@ def codegen(context, builder, sig, args):
             fname = 'str_arr_to_float64'
         else:
             assert sig.args[3].dtype == types.int64
-        fn_to_numeric = builder.module.get_or_insert_function(fnty, fname)
+        fn_to_numeric = cgutils.get_or_insert_function(builder.module, fnty, fname)
         return builder.call(
             fn_to_numeric,
             [out_ptr, string_array.offsets, string_array.data, ind])
@@ -1209,7 +1212,7 @@ def unbox_str_series(typ, val, c):
                              lir.IntType(8).as_pointer().as_pointer(),
                              lir.IntType(8).as_pointer().as_pointer(),
                              ])
-    fn = c.builder.module.get_or_insert_function(fnty, name="string_array_from_sequence")
+    fn = cgutils.get_or_insert_function(c.builder.module, fnty, name="string_array_from_sequence")
     c.builder.call(fn, [val,
                         string_array._get_ptr_by_name('num_items'),
                         payload._get_ptr_by_name('offsets'),
@@ -1268,7 +1271,7 @@ def lower_glob(context, builder, sig, args):
                              lir.IntType(8).as_pointer().as_pointer(),
                              lir.IntType(64).as_pointer(),
                              lir.IntType(8).as_pointer()])
-    fn = builder.module.get_or_insert_function(fnty, name="c_glob")
+    fn = cgutils.get_or_insert_function(builder.module, fnty, name="c_glob")
     builder.call(fn, [str_arr_payload._get_ptr_by_name('offsets'),
                       str_arr_payload._get_ptr_by_name('data'),
                       str_arr_payload._get_ptr_by_name('null_bitmap'),
diff --git a/sdc/str_ext.py b/sdc/str_ext.py
index 13c78aba1..01b754f77 100644
--- a/sdc/str_ext.py
+++ b/sdc/str_ext.py
@@ -30,6 +30,7 @@
 import llvmlite.llvmpy.core as lc
 from llvmlite import ir as lir
 import llvmlite.binding as ll
+import numpy as np
 
 import numba
 from numba.core import cgutils, types
@@ -230,7 +231,7 @@ def impl(_str, ind):
 def getitem_string(context, builder, sig, args):
     fnty = lir.FunctionType(lir.IntType(8),
                             [lir.IntType(8).as_pointer(), lir.IntType(64)])
-    fn = builder.module.get_or_insert_function(fnty, name="get_char_from_string")
+    fn = cgutils.get_or_insert_function(builder.module, fnty, name="get_char_from_string")
     return builder.call(fn, args)
 
 
@@ -240,7 +241,7 @@ def box_char(typ, val, c):
     """
     fnty = lir.FunctionType(lir.IntType(8).as_pointer(),
                             [lir.IntType(8)])
-    fn = c.builder.module.get_or_insert_function(fnty, name="get_char_ptr")
+    fn = cgutils.get_or_insert_function(c.builder.module, fnty, name="get_char_ptr")
     c_str = c.builder.call(fn, [val])
     pystr = c.pyapi.string_from_string_and_size(c_str, c.context.get_constant(types.intp, 1))
     # TODO: delete ptr
@@ -406,15 +407,6 @@ def generic(self, args, kws):
             return signature(types.float64, arg)
 
 
-@infer_global(str)
-class StrConstInfer(AbstractTemplate):
-    def generic(self, args, kws):
-        assert not kws
-        assert len(args) == 1
-        assert args[0] in [types.int32, types.int64, types.float32, types.float64, string_type]
-        return signature(string_type, *args)
-
-
 class RegexType(types.Opaque):
     def __init__(self):
         super(RegexType, self).__init__(name='RegexType')
@@ -494,7 +486,7 @@ def gen_unicode_to_std_str(context, builder, unicode_val):
         context, builder, value=unicode_val)
     fnty = lir.FunctionType(lir.IntType(8).as_pointer(),
                             [lir.IntType(8).as_pointer(), lir.IntType(64)])
-    fn = builder.module.get_or_insert_function(fnty, name="init_string_const")
+    fn = cgutils.get_or_insert_function(builder.module, fnty, name="init_string_const")
     return builder.call(fn, [uni_str.data, uni_str.length])
 
 
@@ -584,7 +576,7 @@ def unbox_string(typ, obj, c):
 
     fnty = lir.FunctionType(lir.IntType(8).as_pointer(),
                             [lir.IntType(8).as_pointer(), lir.IntType(64)])
-    fn = c.builder.module.get_or_insert_function(fnty, name="init_string")
+    fn = cgutils.get_or_insert_function(c.builder.module, fnty, name="init_string")
     ret = c.builder.call(fn, [buffer, size])
 
     return NativeValue(ret, is_error=c.builder.not_(ok))
@@ -596,7 +588,7 @@ def box_str(typ, val, c):
     """
     fnty = lir.FunctionType(lir.IntType(8).as_pointer(),
                             [lir.IntType(8).as_pointer()])
-    fn = c.builder.module.get_or_insert_function(fnty, name="get_c_str")
+    fn = cgutils.get_or_insert_function(c.builder.module, fnty, name="get_c_str")
     c_str = c.builder.call(fn, [val])
     pystr = c.pyapi.string_from_string(c_str)
     return pystr
@@ -618,7 +610,7 @@ def getpointer_from_string(context, builder, sig, args):
     val = args[0]
     fnty = lir.FunctionType(lir.IntType(8).as_pointer(),
                             [lir.IntType(8).as_pointer()])
-    fn = builder.module.get_or_insert_function(fnty, name="get_c_str")
+    fn = cgutils.get_or_insert_function(builder.module, fnty, name="get_c_str")
     c_str = builder.call(fn, [val])
     return c_str
 
@@ -637,7 +629,7 @@ def string_type_to_const(context, builder, fromty, toty, val):
     # call str == cstr
     fnty = lir.FunctionType(lir.IntType(1),
                             [lir.IntType(8).as_pointer(), lir.IntType(8).as_pointer()])
-    fn = builder.module.get_or_insert_function(fnty, name="str_equal_cstr")
+    fn = cgutils.get_or_insert_function(builder.module, fnty, name="str_equal_cstr")
     match = builder.call(fn, [val, cstr])
     with cgutils.if_unlikely(builder, builder.not_(match)):
         # Raise RuntimeError about the assumption violation
@@ -655,7 +647,7 @@ def const_string(context, builder, ty, pyval):
 
     fnty = lir.FunctionType(lir.IntType(8).as_pointer(),
                             [lir.IntType(8).as_pointer(), lir.IntType(64)])
-    fn = builder.module.get_or_insert_function(fnty, name="init_string_const")
+    fn = cgutils.get_or_insert_function(builder.module, fnty, name="init_string_const")
     ret = builder.call(fn, [cstr, length])
     return ret
 
@@ -667,22 +659,23 @@ def const_to_string_type(context, builder, fromty, toty, val):
 
     fnty = lir.FunctionType(lir.IntType(8).as_pointer(),
                             [lir.IntType(8).as_pointer(), lir.IntType(64)])
-    fn = builder.module.get_or_insert_function(fnty, name="init_string_const")
+    fn = cgutils.get_or_insert_function(builder.module, fnty, name="init_string_const")
     ret = builder.call(fn, [cstr, length])
     return ret
 
 
-@lower_builtin(str, types.Any)
-def string_from_impl(context, builder, sig, args):
-    in_typ = sig.args[0]
-    if in_typ == string_type:
-        return args[0]
-    ll_in_typ = context.get_value_type(sig.args[0])
-    fnty = lir.FunctionType(lir.IntType(8).as_pointer(), [ll_in_typ])
-    fn = builder.module.get_or_insert_function(
-        fnty, name="str_from_" + str(in_typ))
-    std_str = builder.call(fn, args)
-    return gen_std_str_to_unicode(context, builder, std_str)
+@overload(str)
+def str_from_float_ovld(val):
+    if not isinstance(val, types.Float):
+        return None
+
+    val_type_precision = np.finfo(val.key).precision
+
+    def str_from_float_impl(val):
+        with numba.objmode(res='types.unicode_type'):
+            res = np.format_float_positional(val, val_type_precision)
+        return res
+    return str_from_float_impl
 
 
 @lower_builtin(operator.add, std_str_type, std_str_type)
@@ -690,7 +683,7 @@ def string_from_impl(context, builder, sig, args):
 def impl_string_concat(context, builder, sig, args):
     fnty = lir.FunctionType(lir.IntType(8).as_pointer(),
                             [lir.IntType(8).as_pointer(), lir.IntType(8).as_pointer()])
-    fn = builder.module.get_or_insert_function(fnty, name="str_concat")
+    fn = cgutils.get_or_insert_function(builder.module, fnty, name="str_concat")
     return builder.call(fn, args)
 
 
@@ -699,7 +692,7 @@ def impl_string_concat(context, builder, sig, args):
 def string_eq_impl(context, builder, sig, args):
     fnty = lir.FunctionType(lir.IntType(1),
                             [lir.IntType(8).as_pointer(), lir.IntType(8).as_pointer()])
-    fn = builder.module.get_or_insert_function(fnty, name="str_equal")
+    fn = cgutils.get_or_insert_function(builder.module, fnty, name="str_equal")
     return builder.call(fn, args)
 
 
@@ -718,7 +711,7 @@ def char_eq_impl(c1, c2):
 def string_neq_impl(context, builder, sig, args):
     fnty = lir.FunctionType(lir.IntType(1),
                             [lir.IntType(8).as_pointer(), lir.IntType(8).as_pointer()])
-    fn = builder.module.get_or_insert_function(fnty, name="str_equal")
+    fn = cgutils.get_or_insert_function(builder.module, fnty, name="str_equal")
     return builder.not_(builder.call(fn, args))
 
 
@@ -727,7 +720,7 @@ def string_neq_impl(context, builder, sig, args):
 def string_ge_impl(context, builder, sig, args):
     fnty = lir.FunctionType(lir.IntType(32),
                             [lir.IntType(8).as_pointer(), lir.IntType(8).as_pointer()])
-    fn = builder.module.get_or_insert_function(fnty, name="str_compare")
+    fn = cgutils.get_or_insert_function(builder.module, fnty, name="str_compare")
     comp_val = builder.call(fn, args)
     zero = context.get_constant(types.int32, 0)
     res = builder.icmp(lc.ICMP_SGE, comp_val, zero)
@@ -739,7 +732,7 @@ def string_ge_impl(context, builder, sig, args):
 def string_gt_impl(context, builder, sig, args):
     fnty = lir.FunctionType(lir.IntType(32),
                             [lir.IntType(8).as_pointer(), lir.IntType(8).as_pointer()])
-    fn = builder.module.get_or_insert_function(fnty, name="str_compare")
+    fn = cgutils.get_or_insert_function(builder.module, fnty, name="str_compare")
     comp_val = builder.call(fn, args)
     zero = context.get_constant(types.int32, 0)
     res = builder.icmp(lc.ICMP_SGT, comp_val, zero)
@@ -751,7 +744,7 @@ def string_gt_impl(context, builder, sig, args):
 def string_le_impl(context, builder, sig, args):
     fnty = lir.FunctionType(lir.IntType(32),
                             [lir.IntType(8).as_pointer(), lir.IntType(8).as_pointer()])
-    fn = builder.module.get_or_insert_function(fnty, name="str_compare")
+    fn = cgutils.get_or_insert_function(builder.module, fnty, name="str_compare")
     comp_val = builder.call(fn, args)
     zero = context.get_constant(types.int32, 0)
     res = builder.icmp(lc.ICMP_SLE, comp_val, zero)
@@ -763,7 +756,7 @@ def string_le_impl(context, builder, sig, args):
 def string_lt_impl(context, builder, sig, args):
     fnty = lir.FunctionType(lir.IntType(32),
                             [lir.IntType(8).as_pointer(), lir.IntType(8).as_pointer()])
-    fn = builder.module.get_or_insert_function(fnty, name="str_compare")
+    fn = cgutils.get_or_insert_function(builder.module, fnty, name="str_compare")
     comp_val = builder.call(fn, args)
     zero = context.get_constant(types.int32, 0)
     res = builder.icmp(lc.ICMP_SLT, comp_val, zero)
@@ -777,7 +770,7 @@ def string_split_impl(context, builder, sig, args):
     fnty = lir.FunctionType(lir.IntType(8).as_pointer().as_pointer(),
                             [lir.IntType(8).as_pointer(), lir.IntType(8).as_pointer(),
                              lir.IntType(64).as_pointer()])
-    fn = builder.module.get_or_insert_function(fnty, name="str_split")
+    fn = cgutils.get_or_insert_function(builder.module, fnty, name="str_split")
     ptr = builder.call(fn, args + [nitems])
     size = builder.load(nitems)
     # TODO: use ptr instead of allocating and copying, use NRT_MemInfo_new
@@ -796,7 +789,7 @@ def string_split_impl(context, builder, sig, args):
 # def getitem_string(context, builder, sig, args):
 #     fnty = lir.FunctionType(lir.IntType(8).as_pointer(),
 #                             [lir.IntType(8).as_pointer(), lir.IntType(64)])
-#     fn = builder.module.get_or_insert_function(fnty, name="str_substr_int")
+#     fn = cgutils.get_or_insert_function(builder.module, fnty, name="str_substr_int")
 #     # TODO: handle reference counting
 #     # return impl_ret_new_ref(builder.call(fn, args))
 #     return (builder.call(fn, args))
@@ -805,9 +798,10 @@ def string_split_impl(context, builder, sig, args):
 @lower_cast(StringType, types.int64)
 def cast_str_to_int64(context, builder, fromty, toty, val):
     fnty = lir.FunctionType(lir.IntType(64), [lir.IntType(8).as_pointer()])
-    fn = builder.module.get_or_insert_function(fnty, name="std_str_to_int64")
+    fn = cgutils.get_or_insert_function(builder.module, fnty, name="std_str_to_int64")
     return builder.call(fn, (val,))
 
+
 # # XXX handle unicode until Numba supports int(str)
 # @lower_cast(string_type, types.int64)
 # def cast_unicode_str_to_int64(context, builder, fromty, toty, val):
@@ -818,7 +812,7 @@ def cast_str_to_int64(context, builder, fromty, toty, val):
 @lower_cast(StringType, types.float64)
 def cast_str_to_float64(context, builder, fromty, toty, val):
     fnty = lir.FunctionType(lir.DoubleType(), [lir.IntType(8).as_pointer()])
-    fn = builder.module.get_or_insert_function(fnty, name="str_to_float64")
+    fn = cgutils.get_or_insert_function(builder.module, fnty, name="str_to_float64")
     return builder.call(fn, (val,))
 
 # XXX handle unicode until Numba supports float(str)
@@ -831,7 +825,7 @@ def cast_unicode_str_to_float64(context, builder, fromty, toty, val):
 # def len_string(context, builder, sig, args):
 #     fnty = lir.FunctionType(lir.IntType(64),
 #                             [lir.IntType(8).as_pointer()])
-#     fn = builder.module.get_or_insert_function(fnty, name="get_str_len")
+#     fn = cgutils.get_or_insert_function(builder.module, fnty, name="get_str_len")
 #     return (builder.call(fn, args))
 
 
@@ -839,7 +833,7 @@ def cast_unicode_str_to_float64(context, builder, fromty, toty, val):
 def lower_compile_regex(context, builder, sig, args):
     fnty = lir.FunctionType(lir.IntType(8).as_pointer(),
                             [lir.IntType(8).as_pointer()])
-    fn = builder.module.get_or_insert_function(fnty, name="compile_regex")
+    fn = cgutils.get_or_insert_function(builder.module, fnty, name="compile_regex")
     return builder.call(fn, args)
 
 
@@ -854,7 +848,7 @@ def lower_compile_regex_unicode(context, builder, sig, args):
 def impl_string_contains_regex(context, builder, sig, args):
     fnty = lir.FunctionType(lir.IntType(1),
                             [lir.IntType(8).as_pointer(), lir.IntType(8).as_pointer()])
-    fn = builder.module.get_or_insert_function(fnty, name="str_contains_regex")
+    fn = cgutils.get_or_insert_function(builder.module, fnty, name="str_contains_regex")
     return builder.call(fn, args)
 
 
@@ -870,7 +864,7 @@ def impl_unicode_string_contains_regex(context, builder, sig, args):
 def impl_string_contains_noregex(context, builder, sig, args):
     fnty = lir.FunctionType(lir.IntType(1),
                             [lir.IntType(8).as_pointer(), lir.IntType(8).as_pointer()])
-    fn = builder.module.get_or_insert_function(
+    fn = cgutils.get_or_insert_function(builder.module,
         fnty, name="str_contains_noregex")
     return builder.call(fn, args)
 
diff --git a/sdc/tests/indexes/test_int64_index.py b/sdc/tests/indexes/test_int64_index.py
index 27f518919..c6cc732c2 100644
--- a/sdc/tests/indexes/test_int64_index.py
+++ b/sdc/tests/indexes/test_int64_index.py
@@ -389,32 +389,33 @@ def test_impl(index1, index2):
                 np.testing.assert_array_equal(result, result_ref)
 
     def test_int64_index_operator_is_nounbox(self):
-        def test_impl_1(data):
-            index1 = pd.Int64Index(data)
+        # positive testcase
+        def test_impl_1(data, name):
+            index1 = pd.Int64Index(data, name=name)
             index2 = index1
             return index1 is index2
-        sdc_func_1 = self.jit(test_impl_1)
 
-        def test_impl_2(data):
-            index1 = pd.Int64Index(data)
-            index2 = pd.Int64Index(data)
+        # negative testcase
+        def test_impl_2(data, name):
+            index1 = pd.Int64Index(data, name=name)
+            index2 = pd.Int64Index(data, name=name)
             return index1 is index2
-        sdc_func_2 = self.jit(test_impl_2)
 
-        # positive testcase
-        index_data = [1, 2, 3, 5, 6, 3, 4]
-        with self.subTest(subtest="same indexes"):
-            result = sdc_func_1(index_data)
-            result_ref = test_impl_1(index_data)
-            self.assertEqual(result, result_ref)
-            self.assertEqual(result, True)
+        index_data = pd.Int64Index([1, 2, 3, 5, 6, 3, 4]).values
+        compiled_funcs = [
+            (test_impl_1, "same indexes"),
+            (test_impl_2, "not same indexes")
+        ]
 
-        # negative testcase
-        with self.subTest(subtest="not same indexes"):
-            result = sdc_func_2(index_data)
-            result_ref = test_impl_2(index_data)
-            self.assertEqual(result, result_ref)
-            self.assertEqual(result, False)
+        for pyfuncs, name in product(compiled_funcs, test_global_index_names):
+            func, descr = pyfuncs
+            sdc_func = self.jit(func)
+            with self.subTest(subtest=f"{descr}, name={name}"):
+                result = sdc_func(index_data, name)
+                result_ref = func(index_data, name)
+                expected = True if descr == "same indexes" else False
+                self.assertEqual(result, result_ref)
+                self.assertEqual(result, expected)
 
     def test_int64_index_getitem_by_mask(self):
         def test_impl(index, mask):
diff --git a/sdc/tests/test_io.py b/sdc/tests/test_io.py
index 55fead5ba..3acd89894 100644
--- a/sdc/tests/test_io.py
+++ b/sdc/tests/test_io.py
@@ -250,9 +250,9 @@ def test_pyarrow(self):
             "csv_parallel1",
             "csv_str_parallel1",
             "csv_usecols1",
-            "csv_cat1",
-            "csv_cat2",
-            "csv_single_dtype1",
+            # "csv_cat1",
+            # "csv_cat2",
+            # "csv_single_dtype1",
         ]
         for test in tests:
             with self.subTest(test=test):
diff --git a/sdc/tests/test_strings.py b/sdc/tests/test_strings.py
index 9876efb86..5b9d245cf 100644
--- a/sdc/tests/test_strings.py
+++ b/sdc/tests/test_strings.py
@@ -146,13 +146,23 @@ def test_impl(_str):
     def test_string_str_cast(self):
         def test_impl(a):
             return str(a)
-        hpat_func = self.jit(test_impl)
-
-        for arg in [np.int32(45), 43, np.float32(1.4), 4.5]:
-            py_res = test_impl(arg)
-            h_res = hpat_func(arg)
-            # XXX: use startswith since hpat output can have extra characters
-            self.assertTrue(h_res.startswith(py_res))
+        sdc_func = self.jit(test_impl)
+
+        tested_values = [
+            np.int32(45),
+            43,
+            np.float32(1.4),
+            np.float64(1.4),
+            4.5,
+            np.float64(np.nan)
+        ]
+        for val in tested_values:
+            with self.subTest(val=val):
+                result_ref = test_impl(val)
+                result = sdc_func(val)
+                # XXX: use startswith since hpat output can have extra characters
+                self.assertTrue(result.startswith(result_ref),
+                                f"result={result} not started with {result_ref}")
 
     def test_re_sub(self):
         def test_impl(_str):
diff --git a/sdc/utilities/sdc_typing_utils.py b/sdc/utilities/sdc_typing_utils.py
index 31dc54035..53fd39f8b 100644
--- a/sdc/utilities/sdc_typing_utils.py
+++ b/sdc/utilities/sdc_typing_utils.py
@@ -37,9 +37,8 @@
 from numba.core.errors import TypingError
 from numba.np import numpy_support
 
-from sdc.str_arr_type import string_array_type
 from sdc.datatypes.indexes import *
-from sdc.str_arr_ext import StringArrayType
+from sdc.str_arr_type import string_array_type, StringArrayType
 from sdc.datatypes.categorical.types import Categorical
 
 
diff --git a/sdc/utilities/utils.py b/sdc/utilities/utils.py
index bdce82b0a..7a4c54dea 100644
--- a/sdc/utilities/utils.py
+++ b/sdc/utilities/utils.py
@@ -136,50 +136,6 @@ class NotConstant:
 def unliteral_all(args):
     return tuple(types.unliteral(a) for a in args)
 
-# TODO: move to Numba
-
-
-class BooleanLiteral(types.Literal, types.Boolean):
-
-    def __init__(self, value):
-        self._literal_init(value)
-        name = 'Literal[bool]({})'.format(value)
-        basetype = self.literal_type
-        types.Boolean.__init__(
-            self,
-            name=name
-            )
-
-    def can_convert_to(self, typingctx, other):
-        # similar to IntegerLiteral
-        conv = typingctx.can_convert(self.literal_type, other)
-        if conv is not None:
-            return max(conv, types.Conversion.promote)
-
-
-types.Literal.ctor_map[bool] = BooleanLiteral
-register_default(BooleanLiteral)(numba.core.datamodel.models.BooleanModel)
-
-
-@lower_cast(BooleanLiteral, types.boolean)
-def literal_bool_cast(context, builder, fromty, toty, val):
-    lit = context.get_constant_generic(
-        builder,
-        fromty.literal_type,
-        fromty.literal_value,
-    )
-    return context.cast(builder, lit, fromty.literal_type, toty)
-
-
-lower_builtin(operator.eq, BooleanLiteral, BooleanLiteral)(numba.cpython.builtins.const_eq_impl)
-lower_builtin(operator.ne, BooleanLiteral, BooleanLiteral)(numba.cpython.builtins.const_ne_impl)
-
-
-@lower_builtin(bool, BooleanLiteral)
-def bool_as_bool(context, builder, sig, args):
-    [val] = args
-    return val
-
 
 def get_constant(func_ir, var, default=NOT_CONSTANT):
     def_node = guard(get_definition, func_ir, var)
@@ -308,14 +264,14 @@ def cprint_lower(context, builder, sig, args):
         if typ == string_type:
             fnty = lir.FunctionType(
                 lir.VoidType(), [lir.IntType(8).as_pointer()])
-            fn = builder.module.get_or_insert_function(fnty, name="print_str")
+            fn = cgutils.get_or_insert_function(builder.module, fnty, name="print_str")
             builder.call(fn, [val])
             cgutils.printf(builder, " ")
             continue
         if typ == char_type:
             fnty = lir.FunctionType(
                 lir.VoidType(), [lir.IntType(8)])
-            fn = builder.module.get_or_insert_function(fnty, name="print_char")
+            fn = cgutils.get_or_insert_function(builder.module, fnty, name="print_char")
             builder.call(fn, [val])
             cgutils.printf(builder, " ")
             continue
diff --git a/setup.py b/setup.py
index 0d494bf2a..c717bf235 100644
--- a/setup.py
+++ b/setup.py
@@ -405,7 +405,7 @@ def run(self):
           'numpy>=1.16',
           'pandas==1.2.0',
           'pyarrow==4.0.1',
-          'numba==0.53.1',
+          'numba==0.54.1',
           'tbb'
           ],
       cmdclass=sdc_build_commands,