[build] turn on Werror

rhilkens · JaccovG · commit a7922d828416 · 2021-04-15T09:33:34.000+02:00
diff --git a/lib/mli_lib.cmake b/lib/mli_lib.cmake
@@ -73,24 +73,32 @@ set(MLI_LIB_PRIVATE_INCLUDES
     ${MLI_LIB_CMAKE_DIR}/src/pal
 )
 
+set(MLI_LIB_PRIVATE_COMPILE_OPTIONS )
+
 if (ARC)
-    set(MLI_LIB_PRIVATE_COMPILE_OPTIONS
+    list(APPEND MLI_LIB_PRIVATE_COMPILE_OPTIONS
         -Hnocopyr
         -Hpurge
         -Hsdata0
         -Hdense_prologue
+        -tcf_core_config
+)
+endif()
+
+if (ARC)
+    list(APPEND MLI_LIB_PRIVATE_COMPILE_OPTIONS
+        -Werror
         -Wall
         -Wno-nonportable-include-path
-        -tcf_core_config
     )
 elseif (MSVC)
-    set(MLI_LIB_PRIVATE_COMPILE_OPTIONS
-        /W3
+    list(APPEND MLI_LIB_PRIVATE_COMPILE_OPTIONS
+        /W2
+        /WX
     )
 else()
-    set(MLI_LIB_PRIVATE_COMPILE_OPTIONS
+    list(APPEND MLI_LIB_PRIVATE_COMPILE_OPTIONS
         -Werror
-        -Wno-nonportable-include-path
     )
 endif()
 
diff --git a/lib/src/helpers/src/impl/mli_hlp_convert_tensor_ref.h b/lib/src/helpers/src/impl/mli_hlp_convert_tensor_ref.h
@@ -1,5 +1,5 @@
 /*
-* Copyright 2020, Synopsys, Inc.
+* Copyright 2020-2021, Synopsys, Inc.
 * All rights reserved.
 *
 * This source code is licensed under the BSD-3-Clause license found in
@@ -176,7 +176,7 @@ mli_status convert_float_data(const mli_tensor * src, mli_tensor * dst, convert_
                                 int32_t tensor_val = mli_math_float_scale(float_tensor_arr[float_tensor_pos], scale_val);
                                 tensor_arr[tensor_pos] = mli_math_cast_fx<int32_t, t_T>(mli_math_add_fx<int32_t>(tensor_val, zero_offset), 0);
                             } else if (mode == mli::hlp::DEQUANTIZE) {
-                                const float float_tensor_val_unscaled = static_cast<float>(mli_math_sub_fx<int32_t>(tensor_arr[tensor_pos], zero_offset));
+                                const float float_tensor_val_unscaled = static_cast<float>(mli_math_sub_fx<int32_t>((int32_t)(tensor_arr[tensor_pos]), zero_offset));
                                 float_tensor_arr[float_tensor_pos] = float_tensor_val_unscaled * scale_val;
                             }
                         }
diff --git a/lib/src/move/mli_mov_api.cc b/lib/src/move/mli_mov_api.cc
@@ -12,6 +12,7 @@
 #include "mli_api.h"
 #include "mli_debug.h"
 #include "mli_math_macros.h"
+#include "mli_mem_info.h"
 #include "mli_mov_api.h"
 #include "mli_mov.h"
 #include "mli_types.h"
@@ -107,8 +108,8 @@ mli_status mli_mov_prepare(mli_mov_handle_t* h, const mli_tensor* src, const mli
     int rank = dst->rank = src->rank;
     dst->el_type = src->el_type;
 
-    const bool src_in_vccm = mli_prv_is_inside_vccm(src->data.mem.void_p);
-    const bool dst_in_vccm = mli_prv_is_inside_vccm(dst->data.mem.void_p);
+    const bool src_in_vccm = mli_mem_is_inside_vccm(src->data.mem.void_p);
+    const bool dst_in_vccm = mli_mem_is_inside_vccm(dst->data.mem.void_p);
 
     if ((src->el_type == MLI_EL_SA_8 || src->el_type == MLI_EL_SA_32) && (src->el_params.sa.dim != -1)) {
         if ((dst->el_params.sa.scale.mem.pi16 != src->el_params.sa.scale.mem.pi16) &&
diff --git a/lib/src/pal/mli_mem_info.h b/lib/src/pal/mli_mem_info.h
@@ -0,0 +1,91 @@
+/*
+* Copyright 2021, Synopsys, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the BSD-3-Clause license found in
+* the LICENSE file in the root directory of this source tree.
+*
+*/
+
+#ifndef _MLI_MEM_INFO_H_
+#define _MLI_MEM_INFO_H_
+
+#include "mli_config.h"
+#include "mli_types.h"
+
+#ifdef _ARC
+#include <arc/arc_reg.h>
+
+#define SUPPORT_NON_ALIGNMENT  22
+#define DISABLE_ALIGNMENT_CHECK 19
+#endif
+
+static MLI_FORCE_INLINE bool mli_mem_is_inside_dccm(const void *ptr) {
+#ifdef core_config_dccm_size
+    return ((uint32_t)ptr >= core_config_dccm_base) &&
+           ((uint32_t)ptr < core_config_dccm_base + core_config_dccm_size);
+#else
+    return false;
+#endif
+}
+
+static MLI_FORCE_INLINE bool mli_mem_is_inside_yccm(const void *ptr) {
+#ifdef core_config_xy_y_base
+    return ((uint32_t)ptr >= core_config_xy_y_base) &&
+           ((uint32_t)ptr < core_config_xy_y_base + core_config_xy_size);
+#else
+    return false;
+#endif
+}
+
+static MLI_FORCE_INLINE bool mli_mem_is_inside_xccm(const void *ptr) {
+#ifdef core_config_xy_x_base
+    return ((uint32_t)ptr >= core_config_xy_x_base) &&
+           ((uint32_t)ptr < core_config_xy_x_base + core_config_xy_size);
+#else
+    return false;
+#endif
+}
+
+static MLI_FORCE_INLINE bool mli_mem_is_inside_vccm(const void *ptr) {
+#ifdef core_config_vec_mem_size
+    return ((uint32_t)ptr >= core_config_vec_mem_base) &&
+           ((uint32_t)ptr < core_config_vec_mem_base + core_config_vec_mem_size);
+#else
+    return false;
+#endif
+}
+
+static MLI_FORCE_INLINE bool mli_mem_is_inside_ccm(const void *ptr) {
+    return mli_mem_is_inside_dccm(ptr)
+        || mli_mem_is_inside_xccm(ptr)
+        || mli_mem_is_inside_yccm(ptr)
+        || mli_mem_is_inside_vccm(ptr);
+}
+
+static MLI_FORCE_INLINE mli_status mli_mem_chk_ptr(void *p, uint32_t align_mask, bool check_bank, bool vccm_chk_bank) {
+#if MLI_PTR_IS_VCCM
+    bool is_inside_vccm = mli_mem_is_inside_vccm(p);
+    if (vccm_chk_bank && (!is_inside_vccm))
+        return MLI_STATUS_MEM_BANK_MISMATCH;
+    //Check the alignment if the pointer is inside the VCCM memory or the non_alignment isn't supported
+    if (is_inside_vccm ||
+        (((_lr(ISA_CONFIG)&(1<<SUPPORT_NON_ALIGNMENT)) == 0) || ((_lr(STATUS32)&(1<<DISABLE_ALIGNMENT_CHECK)) == 0))) {
+        if (((uint32_t)p & align_mask) != 0)
+            return MLI_STATUS_MISALIGNMENT_ERROR;
+    }
+#endif
+#if MLI_PTR_IS_XY
+    if (check_bank && (!mli_mem_is_inside_ccm(p)))
+        return MLI_STATUS_MEM_BANK_MISMATCH;
+#endif
+#if (PLATFORM == V2DSP_XY) || ((PLATFORM == V2DSP_VECTOR) && (!MLI_PTR_IS_VCCM))
+    if (((_lr(ISA_CONFIG)&(1<<SUPPORT_NON_ALIGNMENT)) == 0) || ((_lr(STATUS32)&(1<<DISABLE_ALIGNMENT_CHECK)) == 0)) {
+        if (((uint32_t)p & align_mask) != 0)
+            return MLI_STATUS_MISALIGNMENT_ERROR;
+    }
+#endif
+    return MLI_STATUS_OK;
+}
+
+#endif // _MLI_MEM_INFO_H_
diff --git a/lib/src/pal/vdsp/mli_prv_dsp.h b/lib/src/pal/vdsp/mli_prv_dsp.h
@@ -1,5 +1,5 @@
 /*
-* Copyright 2020-2020, Synopsys, Inc.
+* Copyright 2020-2021, Synopsys, Inc.
 * All rights reserved.
 *
 * This source code is licensed under the BSD-3-Clause license found in
@@ -325,25 +325,25 @@ MLI_FORCE_INLINE vNx2accshort_t mli_prv_init_accu(vNx2short_t inp_val) {
     return vvcadd_init(inp_val, (int16_t)0);
 }
 
-static MLI_FORCE_INLINE int32_t  mli_prv_init_accu(int8_t inp_val) {
+static MLI_FORCE_INLINE int32_t mli_prv_init_accu(int8_t inp_val) {
     int32_t acc = inp_val;
     return acc;
 }
 
-static MLI_FORCE_INLINE int32_t  mli_prv_init_accu(int32_t inp_val) {
+static MLI_FORCE_INLINE int32_t mli_prv_init_accu(int32_t inp_val) {
     int32_t acc = inp_val;
     return acc;
 }
 
-static MLI_FORCE_INLINE int32_t  mli_prv_init_accu_with_bias(
+static MLI_FORCE_INLINE int32_t mli_prv_init_accu_with_bias(
         const MLI_PTR(int8_t) __restrict in,
         const int8_t bias,
         const int bias_shift) {
     int32_t accu = mli_math_asr_rnd_fx<int32_t>((int32_t) bias, -bias_shift);
     return accu;
 }
 
-static MLI_FORCE_INLINE int32_t  mli_prv_init_accu_with_bias(
+static MLI_FORCE_INLINE int32_t mli_prv_init_accu_with_bias(
         const MLI_PTR(int16_t) __restrict in,
         const int8_t bias,
         const int bias_shift) {
@@ -377,6 +377,15 @@ MLI_FORCE_INLINE vNx2accint_t mli_prv_init_accu_with_bias_v(
     return mli_math_asl_fx(r, bias_shift);
 }
 
+template<>
+MLI_FORCE_INLINE mli_acc32_t mli_prv_init_accu_with_bias_v(
+        const int16_t bias,
+        const int bias_shift) {
+
+    mli_acc32_t r = bias;
+    return mli_math_asl_fx(r, bias_shift);
+}
+
 template<>
 MLI_FORCE_INLINE mli_acc40_t mli_prv_init_accu_with_bias_v(
         const int16_t bias,
@@ -385,6 +394,7 @@ MLI_FORCE_INLINE mli_acc40_t mli_prv_init_accu_with_bias_v(
     mli_acc40_t r = bias;
     return mli_math_asl_fx(r, bias_shift);
 }
+
 // Multiply and accumulate for vectors of 1, 2, and 4 elements
 //=========================================================================
 // Note:
diff --git a/lib/src/private/mli_prv_tensor.h b/lib/src/private/mli_prv_tensor.h
@@ -1006,12 +1006,4 @@ mli_prv_get_relu_limits (const mli_relu_cfg * cfg, const mli_tensor * out) {
     return val_limit;
 }
 
-static MLI_FORCE_INLINE bool mli_prv_is_inside_vccm (const void *ptr) {
-#if core_config_vec_mem_size
-    return ((uint32_t)ptr >= core_config_vec_mem_base) &&
-           ((uint32_t)ptr < core_config_vec_mem_base + core_config_vec_mem_size);
-#else
-    return false;
-#endif
-}
 #endif //_MLI_PRV_TENSOR_H_
diff --git a/lib/src/private/src/mli_check.cc b/lib/src/private/src/mli_check.cc
@@ -17,85 +17,14 @@
 #include "mli_helpers_api.h"
 #include "mli_math.h"
 #include "mli_math_macros.h"
+#include "mli_mem_info.h"
 #include "mli_prv_activation_lut.h"
 #include "mli_prv_tensor.h"
 #include "mli_types.h"
 
-#if _ARC
-#include <arc/arc_reg.h>
-#endif
 #pragma MLI_CODE_SECTION_START(".mli_lib")
-#define SUPPORT_NON_ALIGNMENT  22
-#define DISABLE_ALIGNMENT_CHECK 19
-
-
-#if core_config_dccm_size
-static MLI_FORCE_INLINE bool mli_chk_inside_dccm (const void *ptr) {
-    return ((uint32_t)ptr >= core_config_dccm_base) &&
-           ((uint32_t)ptr < core_config_dccm_base + core_config_dccm_size);
-}
-#endif
-
-#if core_config_xy_size
-static MLI_FORCE_INLINE bool mli_chk_inside_yccm (const void *ptr) {
-#ifdef core_config_xy_y_base
-    return ((uint32_t)ptr >= core_config_xy_y_base) &&
-           ((uint32_t)ptr < core_config_xy_y_base + core_config_xy_size);
-#else
-    return false;
-#endif
-}
 
-static MLI_FORCE_INLINE bool mli_chk_inside_xccm (const void *ptr) {
-#ifdef core_config_xy_x_base
-    return ((uint32_t)ptr >= core_config_xy_x_base) &&
-           ((uint32_t)ptr < core_config_xy_x_base + core_config_xy_size);
-#else
-    return false;
-#endif
-}
-#endif
-
-#if core_config_xy_size || core_config_dccm_size
-static MLI_FORCE_INLINE bool mli_chk_inside_ccm (const void *ptr) {
-#if core_config_xy_size
-    if (mli_chk_inside_xccm(ptr) || mli_chk_inside_yccm(ptr)) {
-        return true;
-    }
-#endif
-#if core_config_dccm_size
-    if (mli_chk_inside_dccm(ptr)) {
-        return true;
-    }
-#endif
-    return false;
-}
-#endif
 
-static MLI_FORCE_INLINE mli_status mli_chk_ptr(void *p, uint32_t align_mask, bool check_bank, bool vccm_chk_bank) {
-#if MLI_PTR_IS_VCCM
-    bool is_inside_vccm = mli_prv_is_inside_vccm(p);
-    if (vccm_chk_bank && (!is_inside_vccm))
-        return MLI_STATUS_MEM_BANK_MISMATCH;
-    //Check the alignment if the pointer is inside the VCCM memory or the non_alignment isn't supported
-    if (is_inside_vccm ||
-        (((_lr(ISA_CONFIG)&(1<<SUPPORT_NON_ALIGNMENT)) == 0) || ((_lr(STATUS32)&(1<<DISABLE_ALIGNMENT_CHECK)) == 0))) {
-        if (((uint32_t)p & align_mask) != 0)
-            return MLI_STATUS_MISALIGNMENT_ERROR;
-    }
-#endif
-#if MLI_PTR_IS_XY
-    if (check_bank && (!mli_chk_inside_ccm(p)))
-        return MLI_STATUS_MEM_BANK_MISMATCH;
-#endif
-#if (PLATFORM == V2DSP_XY) || ((PLATFORM == V2DSP_VECTOR) && (!MLI_PTR_IS_VCCM))
-    if (((_lr(ISA_CONFIG)&(1<<SUPPORT_NON_ALIGNMENT)) == 0) || ((_lr(STATUS32)&(1<<DISABLE_ALIGNMENT_CHECK)) == 0)) {
-        if (((uint32_t)p & align_mask) != 0)
-            return MLI_STATUS_MISALIGNMENT_ERROR;
-    }
-#endif
-    return MLI_STATUS_OK;
-}
 // vccm_chk_bank will be false for the APIs that does't require the tensor to be in VCCM like data Movement API.
 template <bool vccm_chk_bank = true>
 /*check_bank checks whether the tensor buffer have to be allocated in ccm memory or not and its value will be:
@@ -106,7 +35,7 @@ static MLI_FORCE_INLINE mli_status mli_mem_chk(const mli_tensor *t, bool check_b
 #if (PLATFORM == V2DSP_XY) || (PLATFORM == V2DSP_VECTOR)
     void *p = t->data.mem.void_p;
     uint32_t align_mask = mli_hlp_tensor_element_size(t) - 1;
-    return mli_chk_ptr(p, align_mask, check_bank, vccm_chk_bank);
+    return mli_mem_chk_ptr(p, align_mask, check_bank, vccm_chk_bank);
 #else
     return MLI_STATUS_OK;
 #endif
@@ -163,7 +92,7 @@ mli_status mli_chk_lut(const mli_lut * lut, int buff_size) {
     mli_tensor dummy = { .el_type = lut->type };
     uint32_t align_mask = mli_hlp_tensor_element_size(&dummy) - 1;
 
-    mli_status ret = mli_chk_ptr(p, align_mask, true, true);
+    mli_status ret = mli_mem_chk_ptr(p, align_mask, true, true);
     return ret;
 #else
     return MLI_STATUS_OK;
@@ -416,19 +345,6 @@ static MLI_FORCE_INLINE bool check_quantized_on_tensor(const mli_tensor *t1, con
     return !fail;
 }
 
-/* This function returns maximum value can be stored in tensor according to its type */
-static MLI_FORCE_INLINE const uint32_t mli_hlp_tensor_element_positive_limit(const mli_tensor *in) {
-    switch (in->el_type) {
-    case MLI_EL_FX_8:  return (uint32_t)mli_math_limit_fx<int8_t>(1);
-    case MLI_EL_SA_8:  return (uint32_t)mli_math_limit_fx<int8_t>(1);
-    case MLI_EL_FX_16: return (uint32_t)mli_math_limit_fx<int16_t>(1);
-    case MLI_EL_SA_32: return (uint32_t)mli_math_limit_fx<int32_t>(1);
-    default:
-        MLI_ASSERT(0);
-        return 0;
-    }
-}
-
 /******************************************************
  *  mli_krn_conv2d_hwc parameters checking function
  ******************************************************/

Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	`/*`
`2`		`-* Copyright 2020, Synopsys, Inc.`
	`2`	`+* Copyright 2020-2021, Synopsys, Inc.`
`3`	`3`	`* All rights reserved.`
`4`	`4`	`*`
`5`	`5`	`* This source code is licensed under the BSD-3-Clause license found in`
`@@ -176,7 +176,7 @@ mli_status convert_float_data(const mli_tensor * src, mli_tensor * dst, convert_`
`176`	`176`	`int32_t tensor_val = mli_math_float_scale(float_tensor_arr[float_tensor_pos], scale_val);`
`177`	`177`	`tensor_arr[tensor_pos] = mli_math_cast_fx<int32_t, t_T>(mli_math_add_fx<int32_t>(tensor_val, zero_offset), 0);`
`178`	`178`	`} else if (mode == mli::hlp::DEQUANTIZE) {`
`179`		`- const float float_tensor_val_unscaled = static_cast<float>(mli_math_sub_fx<int32_t>(tensor_arr[tensor_pos], zero_offset));`
	`179`	`+ const float float_tensor_val_unscaled = static_cast<float>(mli_math_sub_fx<int32_t>((int32_t)(tensor_arr[tensor_pos]), zero_offset));`
`180`	`180`	`float_tensor_arr[float_tensor_pos] = float_tensor_val_unscaled * scale_val;`
`181`	`181`	`}`
`182`	`182`	`}`