This is the mail archive of the
gdb-patches@sourceware.org
mailing list for the GDB project.
New ARI warning Thu Dec 20 15:25:46 UTC 2012 in -D 2012-12-20-gmt -r gdb_7_5-branch
- From: GDB Administrator <gdbadmin at sourceware dot org>
- To: gdb-patches at sourceware dot org
- Date: Thu, 20 Dec 2012 15:25:46 +0000
- Subject: New ARI warning Thu Dec 20 15:25:46 UTC 2012 in -D 2012-12-20-gmt -r gdb_7_5-branch
47,48d46
< gdb/arm-tdep.c:310: code: inline: Do not use the inline attribute; since the compiler generally ignores this, better algorithm selection is needed to improved performance
gdb/arm-tdep.c:310:static inline int
< gdb/arm-tdep.c:2161: code: inline: Do not use the inline attribute; since the compiler generally ignores this, better algorithm selection is needed to improved performance
gdb/arm-tdep.c:2161:static inline int
61d58
< gdb/auto-load.c:1086: regression: var_boolean: Replace var_boolean with add_setshow_boolean_cmd
gdb/auto-load.c:1086: if (list->var_type == var_boolean)
136,141d132
< gdb/common/common-utils.c:129: regression: vasprintf: Do not use vasprintf(), instead use xstrvprintf
gdb/common/common-utils.c:129: int status = vasprintf (&ret, format, ap);
< gdb/common/common-utils.c:141: regression: xasprintf: Do not use xasprintf(), instead use xstrprintf
gdb/common/common-utils.c:141:xasprintf (char **ret, const char *format, ...)
< gdb/common/common-utils.c:151: regression: xvasprintf: Do not use xvasprintf(), instead use xstrvprintf
gdb/common/common-utils.c:151:xvasprintf (char **ret, const char *format, va_list ap)
< gdb/common/common-utils.h:48: regression: xasprintf: Do not use xasprintf(), instead use xstrprintf
gdb/common/common-utils.h:48:void xasprintf (char **ret, const char *format, ...)
< gdb/common/common-utils.h:50: regression: xvasprintf: Do not use xvasprintf(), instead use xstrvprintf
gdb/common/common-utils.h:50:void xvasprintf (char **ret, const char *format, va_list ap)
< gdb/common/gdb_assert.h:46: regression: __func__: Do not use __func__, ISO C 90 does not support this macro
gdb/common/gdb_assert.h:46:#define ASSERT_FUNCTION __func__
184,191d174
< gdb/common/vec.c:39: code: inline: Do not use the inline attribute; since the compiler generally ignores this, better algorithm selection is needed to improved performance
gdb/common/vec.c:39:static inline unsigned
< gdb/common/vec.h:419: code: inline: Do not use the inline attribute; since the compiler generally ignores this, better algorithm selection is needed to improved performance
gdb/common/vec.h:419:#define DEF_VEC_I(T) static inline void VEC_OP (T,must_be_integral_type) (void) { (void)~(T)0; } VEC_T(T); DEF_VEC_FUNC_P(T) DEF_VEC_ALLOC_FUNC_I(T) struct vec_swallow_trailing_semi
< gdb/common/vec.h:431: code: inline: Do not use the inline attribute; since the compiler generally ignores this, better algorithm selection is needed to improved performance
gdb/common/vec.h:431:#define DEF_VEC_P(T) static inline void VEC_OP (T,must_be_pointer_type) (void) { (void)((T)1 == (void *)1); } VEC_T(T); DEF_VEC_FUNC_P(T) DEF_VEC_ALLOC_FUNC_P(T) struct vec_swallow_trailing_semi
< gdb/common/vec.h:520: code: inline: Do not use the inline attribute; since the compiler generally ignores this, better algorithm selection is needed to improved performance
gdb/common/vec.h:520:#define DEF_VEC_ALLOC_FUNC_I(T) static inline VEC(T) *VEC_OP (T,alloc) (int alloc_) { return (VEC(T) *) vec_o_reserve (NULL, -alloc_, offsetof (VEC(T),vec), sizeof (T)); } static inline VEC(T) *VEC_OP (T,copy) (VEC(T) *vec_) { size_t len_ = vec_ ? vec_->num : 0; VEC (T) *new_vec_ = NULL; if (len_) { new_vec_ = (VEC (T) *) vec_o_reserve (NULL, -len_, offsetof (VEC(T),vec), sizeof (T)); new_vec_->num = len_; memcpy (new_vec_->vec, vec_->vec, sizeof (T) * len_); } return new_vec_; } static inline void VEC_OP (T,free) (VEC(T) **vec_) { if (*vec_) vec_free_ (*vec_); *vec_ = NULL; } static inline void VEC_OP (T,cleanup) (void *arg_) { VEC(T) **vec_ = arg_; if (*vec_) vec_free_ (*vec_); *vec_ = NULL; } static inline int VEC_OP (T,reserve) (VEC(T) **vec_, int alloc_ VEC_ASSERT_DECL) { int extend = !VEC_OP (T,space) (*vec_, alloc_ < 0 ? -alloc_ : alloc_ VEC_ASSERT_PASS); if (extend) *vec_ = (VEC(T) *) vec_o_reserve (*vec_, alloc_, offsetof (VEC(T),vec), sizeof (T)); return extend; } static inline void VEC_OP (T,safe_grow) (VEC(T) **vec_, int size_ VEC_ASSERT_DECL) { vec_assert (size_ >= 0 && VEC_OP(T,length) (*vec_) <= (unsigned)size_, '); VEC_OP (T,reserve) (vec_, (int)(*vec_ ? (*vec_)->num : 0) - size_ VEC_ASSERT_PASS); (*vec_)->num = size_; } static inline T *VEC_OP (T,safe_push) (VEC(T) **vec_, const T obj_ VEC_ASSERT_DECL) { VEC_OP (T,reserve) (vec_, 1 VEC_ASSERT_PASS); return VEC_OP (T,quick_push) (*vec_, obj_ VEC_ASSERT_PASS); } static inline T *VEC_OP (T,safe_insert) (VEC(T) **vec_, unsigned ix_, const T obj_ VEC_ASSERT_DECL) { VEC_OP (T,reserve) (vec_, 1 VEC_ASSERT_PASS); return VEC_OP (T,quick_insert) (*vec_, ix_, obj_ VEC_ASSERT_PASS); }
< gdb/common/vec.h:703: code: inline: Do not use the inline attribute; since the compiler generally ignores this, better algorithm selection is needed to improved performance
gdb/common/vec.h:703:#define DEF_VEC_FUNC_P(T) static inline unsigned VEC_OP (T,length) (const VEC(T) *vec_) { return vec_ ? vec_->num : 0; } static inline T VEC_OP (T,last) (const VEC(T) *vec_ VEC_ASSERT_DECL) { vec_assert (vec_ && vec_->num, '); return vec_->vec[vec_->num - 1]; } static inline T VEC_OP (T,index) (const VEC(T) *vec_, unsigned ix_ VEC_ASSERT_DECL) { vec_assert (vec_ && ix_ < vec_->num, '); return vec_->vec[ix_]; } static inline int VEC_OP (T,iterate) (const VEC(T) *vec_, unsigned ix_, T *ptr) { if (vec_ && ix_ < vec_->num) { *ptr = vec_->vec[ix_]; return 1; } else { *ptr = 0; return 0; } } static inline size_t VEC_OP (T,embedded_size) (int alloc_) { return offsetof (VEC(T),vec) + alloc_ * sizeof(T); } static inline void VEC_OP (T,embedded_init) (VEC(T) *vec_, int alloc_) { vec_->num = 0; vec_->alloc = alloc_; } static inline int VEC_OP (T,space) (VEC(T) *vec_, int alloc_ VEC_ASSERT_DECL) { vec_assert (alloc_ >= 0, '); return vec_ ? vec_->alloc - vec_->num >= (unsigned)alloc_ : !alloc_; } static inline T *VEC_OP (T,quick_push) (VEC(T) *vec_, T obj_ VEC_ASSERT_DECL) { T *slot_; vec_assert (vec_->num < vec_->alloc, '); slot_ = &vec_->vec[vec_->num++]; *slot_ = obj_; return slot_; } static inline T VEC_OP (T,pop) (VEC(T) *vec_ VEC_ASSERT_DECL) { T obj_; vec_assert (vec_->num, '); obj_ = vec_->vec[--vec_->num]; return obj_; } static inline void VEC_OP (T,truncate) (VEC(T) *vec_, unsigned size_ VEC_ASSERT_DECL) { vec_assert (vec_ ? vec_->num >= size_ : !size_, '); if (vec_) vec_->num = size_; } static inline T VEC_OP (T,replace) (VEC(T) *vec_, unsigned ix_, T obj_ VEC_ASSERT_DECL) { T old_obj_; vec_assert (ix_ < vec_->num, '); old_obj_ = vec_->vec[ix_]; vec_->vec[ix_] = obj_; return old_obj_; } static inline T *VEC_OP (T,quick_insert) (VEC(T) *vec_, unsigned ix_, T obj_ VEC_ASSERT_DECL) { T *slot_; vec_assert (vec_->num < vec_->alloc && ix_ <= vec_->num, '); slot_ = &vec_->vec[ix_]; memmove (slot_ + 1, slot_, (vec_->num++ - ix_) * sizeof (T)); *slot_ = obj_; return slot_; } static inline T VEC_OP (T,ordered_remove) (VEC(T) *vec_, unsigned ix_ VEC_ASSERT_DECL) { T *slot_; T obj_; vec_assert (ix_ < vec_->num, '); slot_ = &vec_->vec[ix_]; obj_ = *slot_; memmove (slot_, slot_ + 1, (--vec_->num - ix_) * sizeof (T)); return obj_; } static inline T VEC_OP (T,unordered_remove) (VEC(T) *vec_, unsigned ix_ VEC_ASSERT_DECL) { T *slot_; T obj_; vec_assert (ix_ < vec_->num, '); slot_ = &vec_->vec[ix_]; obj_ = *slot_; *slot_ = vec_->vec[--vec_->num]; return obj_; } static inline void VEC_OP (T,block_remove) (VEC(T) *vec_, unsigned ix_, unsigned len_ VEC_ASSERT_DECL) { T *slot_; vec_assert (ix_ + len_ <= vec_->num, '); slot_ = &vec_->vec[ix_]; vec_->num -= len_; memmove (slot_, slot_ + len_, (vec_->num - ix_) * sizeof (T)); } static inline T *VEC_OP (T,address) (VEC(T) *vec_) { return vec_ ? vec_->vec : 0; } static inline unsigned VEC_OP (T,lower_bound) (VEC(T) *vec_, const T obj_, int (*lessthan_)(const T, const T) VEC_ASSERT_DECL) { unsigned int len_ = VEC_OP (T, length) (vec_); unsigned int half_, middle_; unsigned int first_ = 0; while (len_ > 0) { T middle_elem_; half_ = len_ >> 1; middle_ = first_; middle_ += half_; middle_elem_ = VEC_OP (T,index) (vec_, middle_ VEC_ASSERT_PASS); if (lessthan_ (middle_elem_, obj_)) { first_ = middle_; ++first_; len_ = len_ - half_ - 1; } else len_ = half_; } return first_; }
< gdb/common/vec.h:782: code: inline: Do not use the inline attribute; since the compiler generally ignores this, better algorithm selection is needed to improved performance
gdb/common/vec.h:782:#define DEF_VEC_ALLOC_FUNC_P(T) static inline VEC(T) *VEC_OP (T,alloc) (int alloc_) { return (VEC(T) *) vec_p_reserve (NULL, -alloc_); } static inline void VEC_OP (T,free) (VEC(T) **vec_) { if (*vec_) vec_free_ (*vec_); *vec_ = NULL; } static inline void VEC_OP (T,cleanup) (void *arg_) { VEC(T) **vec_ = arg_; if (*vec_) vec_free_ (*vec_); *vec_ = NULL; } static inline VEC(T) *VEC_OP (T,copy) (VEC(T) *vec_) { size_t len_ = vec_ ? vec_->num : 0; VEC (T) *new_vec_ = NULL; if (len_) { new_vec_ = (VEC (T) *)(vec_p_reserve (NULL, -len_)); new_vec_->num = len_; memcpy (new_vec_->vec, vec_->vec, sizeof (T) * len_); } return new_vec_; } static inline int VEC_OP (T,reserve) (VEC(T) **vec_, int alloc_ VEC_ASSERT_DECL) { int extend = !VEC_OP (T,space) (*vec_, alloc_ < 0 ? -alloc_ : alloc_ VEC_ASSERT_PASS); if (extend) *vec_ = (VEC(T) *) vec_p_reserve (*vec_, alloc_); return extend; } static inline void VEC_OP (T,safe_grow) (VEC(T) **vec_, int size_ VEC_ASSERT_DECL) { vec_assert (size_ >= 0 && VEC_OP(T,length) (*vec_) <= (unsigned)size_, '); VEC_OP (T,reserve) (vec_, (int)(*vec_ ? (*vec_)->num : 0) - size_ VEC_ASSERT_PASS); (*vec_)->num = size_; } static inline T *VEC_OP (T,safe_push) (VEC(T) **vec_, T obj_ VEC_ASSERT_DECL) { VEC_OP (T,reserve) (vec_, 1 VEC_ASSERT_PASS); return VEC_OP (T,quick_push) (*vec_, obj_ VEC_ASSERT_PASS); } static inline T *VEC_OP (T,safe_insert) (VEC(T) **vec_, unsigned ix_, T obj_ VEC_ASSERT_DECL) { VEC_OP (T,reserve) (vec_, 1 VEC_ASSERT_PASS); return VEC_OP (T,quick_insert) (*vec_, ix_, obj_ VEC_ASSERT_PASS); }
< gdb/common/vec.h:952: code: inline: Do not use the inline attribute; since the compiler generally ignores this, better algorithm selection is needed to improved performance
gdb/common/vec.h:952:#define DEF_VEC_FUNC_O(T) static inline unsigned VEC_OP (T,length) (const VEC(T) *vec_) { return vec_ ? vec_->num : 0; } static inline T *VEC_OP (T,last) (VEC(T) *vec_ VEC_ASSERT_DECL) { vec_assert (vec_ && vec_->num, '); return &vec_->vec[vec_->num - 1]; } static inline T *VEC_OP (T,index) (VEC(T) *vec_, unsigned ix_ VEC_ASSERT_DECL) { vec_assert (vec_ && ix_ < vec_->num, '); return &vec_->vec[ix_]; } static inline int VEC_OP (T,iterate) (VEC(T) *vec_, unsigned ix_, T **ptr) { if (vec_ && ix_ < vec_->num) { *ptr = &vec_->vec[ix_]; return 1; } else { *ptr = 0; return 0; } } static inline size_t VEC_OP (T,embedded_size) (int alloc_) { return offsetof (VEC(T),vec) + alloc_ * sizeof(T); } static inline void VEC_OP (T,embedded_init) (VEC(T) *vec_, int alloc_) { vec_->num = 0; vec_->alloc = alloc_; } static inline int VEC_OP (T,space) (VEC(T) *vec_, int alloc_ VEC_ASSERT_DECL) { vec_assert (alloc_ >= 0, '); return vec_ ? vec_->alloc - vec_->num >= (unsigned)alloc_ : !alloc_; } static inline T *VEC_OP (T,quick_push) (VEC(T) *vec_, const T *obj_ VEC_ASSERT_DECL) { T *slot_; vec_assert (vec_->num < vec_->alloc, '); slot_ = &vec_->vec[vec_->num++]; if (obj_) *slot_ = *obj_; return slot_; } static inline void VEC_OP (T,pop) (VEC(T) *vec_ VEC_ASSERT_DECL) { vec_assert (vec_->num, '); --vec_->num; } static inline void VEC_OP (T,truncate) (VEC(T) *vec_, unsigned size_ VEC_ASSERT_DECL) { vec_assert (vec_ ? vec_->num >= size_ : !size_, '); if (vec_) vec_->num = size_; } static inline T *VEC_OP (T,replace) (VEC(T) *vec_, unsigned ix_, const T *obj_ VEC_ASSERT_DECL) { T *slot_; vec_assert (ix_ < vec_->num, '); slot_ = &vec_->vec[ix_]; if (obj_) *slot_ = *obj_; return slot_; } static inline T *VEC_OP (T,quick_insert) (VEC(T) *vec_, unsigned ix_, const T *obj_ VEC_ASSERT_DECL) { T *slot_; vec_assert (vec_->num < vec_->alloc && ix_ <= vec_->num, '); slot_ = &vec_->vec[ix_]; memmove (slot_ + 1, slot_, (vec_->num++ - ix_) * sizeof (T)); if (obj_) *slot_ = *obj_; return slot_; } static inline void VEC_OP (T,ordered_remove) (VEC(T) *vec_, unsigned ix_ VEC_ASSERT_DECL) { T *slot_; vec_assert (ix_ < vec_->num, '); slot_ = &vec_->vec[ix_]; memmove (slot_, slot_ + 1, (--vec_->num - ix_) * sizeof (T)); } static inline void VEC_OP (T,unordered_remove) (VEC(T) *vec_, unsigned ix_ VEC_ASSERT_DECL) { vec_assert (ix_ < vec_->num, '); vec_->vec[ix_] = vec_->vec[--vec_->num]; } static inline void VEC_OP (T,block_remove) (VEC(T) *vec_, unsigned ix_, unsigned len_ VEC_ASSERT_DECL) { T *slot_; vec_assert (ix_ + len_ <= vec_->num, '); slot_ = &vec_->vec[ix_]; vec_->num -= len_; memmove (slot_, slot_ + len_, (vec_->num - ix_) * sizeof (T)); } static inline T *VEC_OP (T,address) (VEC(T) *vec_) { return vec_ ? vec_->vec : 0; } static inline unsigned VEC_OP (T,lower_bound) (VEC(T) *vec_, const T *obj_, int (*lessthan_)(const T *, const T *) VEC_ASSERT_DECL) { unsigned int len_ = VEC_OP (T, length) (vec_); unsigned int half_, middle_; unsigned int first_ = 0; while (len_ > 0) { T *middle_elem_; half_ = len_ >> 1; middle_ = first_; middle_ += half_; middle_elem_ = VEC_OP (T,index) (vec_, middle_ VEC_ASSERT_PASS); if (lessthan_ (middle_elem_, obj_)) { first_ = middle_; ++first_; len_ = len_ - half_ - 1; } else len_ = half_; } return first_; }
< gdb/common/vec.h:1034: code: inline: Do not use the inline attribute; since the compiler generally ignores this, better algorithm selection is needed to improved performance
gdb/common/vec.h:1034:#define DEF_VEC_ALLOC_FUNC_O(T) static inline VEC(T) *VEC_OP (T,alloc) (int alloc_) { return (VEC(T) *) vec_o_reserve (NULL, -alloc_, offsetof (VEC(T),vec), sizeof (T)); } static inline VEC(T) *VEC_OP (T,copy) (VEC(T) *vec_) { size_t len_ = vec_ ? vec_->num : 0; VEC (T) *new_vec_ = NULL; if (len_) { new_vec_ = (VEC (T) *) vec_o_reserve (NULL, -len_, offsetof (VEC(T),vec), sizeof (T)); new_vec_->num = len_; memcpy (new_vec_->vec, vec_->vec, sizeof (T) * len_); } return new_vec_; } static inline void VEC_OP (T,free) (VEC(T) **vec_) { if (*vec_) vec_free_ (*vec_); *vec_ = NULL; } static inline void VEC_OP (T,cleanup) (void *arg_) { VEC(T) **vec_ = arg_; if (*vec_) vec_free_ (*vec_); *vec_ = NULL; } static inline int VEC_OP (T,reserve) (VEC(T) **vec_, int alloc_ VEC_ASSERT_DECL) { int extend = !VEC_OP (T,space) (*vec_, alloc_ < 0 ? -alloc_ : alloc_ VEC_ASSERT_PASS); if (extend) *vec_ = (VEC(T) *) vec_o_reserve (*vec_, alloc_, offsetof (VEC(T),vec), sizeof (T)); return extend; } static inline void VEC_OP (T,safe_grow) (VEC(T) **vec_, int size_ VEC_ASSERT_DECL) { vec_assert (size_ >= 0 && VEC_OP(T,length) (*vec_) <= (unsigned)size_, '); VEC_OP (T,reserve) (vec_, (int)(*vec_ ? (*vec_)->num : 0) - size_ VEC_ASSERT_PASS); (*vec_)->num = size_; } static inline T *VEC_OP (T,safe_push) (VEC(T) **vec_, const T *obj_ VEC_ASSERT_DECL) { VEC_OP (T,reserve) (vec_, 1 VEC_ASSERT_PASS); return VEC_OP (T,quick_push) (*vec_, obj_ VEC_ASSERT_PASS); } static inline T *VEC_OP (T,safe_insert) (VEC(T) **vec_, unsigned ix_, const T *obj_ VEC_ASSERT_DECL) { VEC_OP (T,reserve) (vec_, 1 VEC_ASSERT_PASS); return VEC_OP (T,quick_insert) (*vec_, ix_, obj_ VEC_ASSERT_PASS); }
274,276d256
< gdb/dwarf2expr.h:300: code: inline: Do not use the inline attribute; since the compiler generally ignores this, better algorithm selection is needed to improved performance
gdb/dwarf2expr.h:300:static inline const gdb_byte *
< gdb/dwarf2expr.h:311: code: inline: Do not use the inline attribute; since the compiler generally ignores this, better algorithm selection is needed to improved performance
gdb/dwarf2expr.h:311:static inline const gdb_byte *
< gdb/dwarf2expr.h:322: code: inline: Do not use the inline attribute; since the compiler generally ignores this, better algorithm selection is needed to improved performance
gdb/dwarf2expr.h:322:static inline const gdb_byte *
278d257
< gdb/dwarf2read.c:3617: code: inline: Do not use the inline attribute; since the compiler generally ignores this, better algorithm selection is needed to improved performance
gdb/dwarf2read.c:3617:static inline int
322a302,304
> gdb/gdb_stat.h:23: regression: stat.h: Do not include stat.h or sys/stat.h, instead include gdb_stat.h
gdb/gdb_stat.h:23:#include <sys/stat.h>
> gdb/gdb_wait.h:23: regression: wait.h: Do not include wait.h or sys/wait.h, instead include gdb_wait.h
gdb/gdb_wait.h:23:#include <sys/wait.h>
> gdb/gdb_wait.h:26: regression: wait.h: Do not include wait.h or sys/wait.h, instead include gdb_wait.h
gdb/gdb_wait.h:26:#include <wait.h>
643a626,628
> gdb/osf-share/RIOS/cma_thread_io.h:410: code: function call in first column: Function name in first column should be restricted to function implementation
gdb/osf-share/RIOS/cma_thread_io.h:410:cma__init_thread_io (void);
> gdb/osf-share/RIOS/cma_thread_io.h:429: code: function call in first column: Function name in first column should be restricted to function implementation
gdb/osf-share/RIOS/cma_thread_io.h:429:cma__is_open (int fd);
> gdb/osf-share/cma_init.h:108: code: function call in first column: Function name in first column should be restricted to function implementation
gdb/osf-share/cma_init.h:108:cma__init_static (void);
731,738d715
< gdb/record.c:243: code: inline: Do not use the inline attribute; since the compiler generally ignores this, better algorithm selection is needed to improved performance
gdb/record.c:243:static inline struct record_entry *
< gdb/record.c:261: code: inline: Do not use the inline attribute; since the compiler generally ignores this, better algorithm selection is needed to improved performance
gdb/record.c:261:static inline void
< gdb/record.c:272: code: inline: Do not use the inline attribute; since the compiler generally ignores this, better algorithm selection is needed to improved performance
gdb/record.c:272:static inline struct record_entry *
< gdb/record.c:289: code: inline: Do not use the inline attribute; since the compiler generally ignores this, better algorithm selection is needed to improved performance
gdb/record.c:289:static inline void
< gdb/record.c:300: code: inline: Do not use the inline attribute; since the compiler generally ignores this, better algorithm selection is needed to improved performance
gdb/record.c:300:static inline struct record_entry *
< gdb/record.c:313: code: inline: Do not use the inline attribute; since the compiler generally ignores this, better algorithm selection is needed to improved performance
gdb/record.c:313:static inline void
< gdb/record.c:322: code: inline: Do not use the inline attribute; since the compiler generally ignores this, better algorithm selection is needed to improved performance
gdb/record.c:322:static inline enum record_type
< gdb/record.c:444: code: inline: Do not use the inline attribute; since the compiler generally ignores this, better algorithm selection is needed to improved performance
gdb/record.c:444:static inline gdb_byte *
740,745d716
< gdb/record.c:702: code: inline: Do not use the inline attribute; since the compiler generally ignores this, better algorithm selection is needed to improved performance
gdb/record.c:702:static inline void
< gdb/record.c:2393: code: inline: Do not use the inline attribute; since the compiler generally ignores this, better algorithm selection is needed to improved performance
gdb/record.c:2393:static inline void
< gdb/record.c:2406: code: inline: Do not use the inline attribute; since the compiler generally ignores this, better algorithm selection is needed to improved performance
gdb/record.c:2406:static inline uint64_t
< gdb/record.c:2416: code: inline: Do not use the inline attribute; since the compiler generally ignores this, better algorithm selection is needed to improved performance
gdb/record.c:2416:static inline uint32_t
< gdb/record.c:2426: code: inline: Do not use the inline attribute; since the compiler generally ignores this, better algorithm selection is needed to improved performance
gdb/record.c:2426:static inline uint16_t
< gdb/record.c:2612: code: inline: Do not use the inline attribute; since the compiler generally ignores this, better algorithm selection is needed to improved performance
gdb/record.c:2612:static inline void
1119,1123d1089
< gdb/utils.c:0: internal: gdb/utils.c missing xasprintf: Expecting 1 occurances of bug xasprintf in file gdb/utils.c, only found 0
gdb/utils.c:0:
gdb/utils.c:0:
gdb/utils.c:0:
< gdb/defs.h:0: internal: gdb/defs.h missing xvasprintf: Expecting 1 occurances of bug xvasprintf in file gdb/defs.h, only found 0
gdb/defs.h:0:
gdb/defs.h:0:
< gdb/utils.c:0: internal: gdb/utils.c missing vasprintf: Expecting 1 occurances of bug vasprintf in file gdb/utils.c, only found 0
gdb/utils.c:0:
gdb/utils.c:0:
gdb/utils.c:0:
< gdb/defs.h:0: internal: gdb/defs.h missing xasprintf: Expecting 1 occurances of bug xasprintf in file gdb/defs.h, only found 0
gdb/defs.h:0:
gdb/defs.h:0:
< gdb/utils.c:0: internal: gdb/utils.c missing xvasprintf: Expecting 1 occurances of bug xvasprintf in file gdb/utils.c, only found 0
gdb/utils.c:0:
gdb/utils.c:0:
gdb/utils.c:0: